#![allow(unknown_lints)]
#![allow(clippy::all)]
#![cfg_attr(rustfmt, rustfmt_skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unsafe_code)]
#![allow(unused_imports)]
#![allow(unused_results)]
use protobuf::Message as Message_imported_for_functions;
use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_8_0;
#[derive(PartialEq,Clone,Default)]
pub struct GetRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub key: ::std::vec::Vec<u8>,
pub version: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a GetRequest {
fn default() -> &'a GetRequest {
<GetRequest as ::protobuf::Message>::default_instance()
}
}
impl GetRequest {
pub fn new() -> GetRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_key(&self) -> &[u8] {
&self.key
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
self.key = v;
}
pub fn mut_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.key
}
pub fn take_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.key, ::std::vec::Vec::new())
}
pub fn get_version(&self) -> u64 {
self.version
}
pub fn clear_version(&mut self) {
self.version = 0;
}
pub fn set_version(&mut self, v: u64) {
self.version = v;
}
}
impl ::protobuf::Message for GetRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.version = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.key);
}
if self.version != 0 {
my_size += ::protobuf::rt::value_size(3, self.version, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.key.is_empty() {
os.write_bytes(2, &self.key)?;
}
if self.version != 0 {
os.write_uint64(3, self.version)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> GetRequest {
GetRequest::new()
}
fn default_instance() -> &'static GetRequest {
static mut instance: ::protobuf::lazy::Lazy<GetRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const GetRequest,
};
unsafe {
instance.get(GetRequest::new)
}
}
}
impl ::protobuf::Clear for GetRequest {
fn clear(&mut self) {
self.context.clear();
self.key.clear();
self.version = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for GetRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.key, "key", buf);
::protobuf::PbPrint::fmt(&self.version, "version", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for GetRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.key, "key", &mut s);
::protobuf::PbPrint::fmt(&self.version, "version", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for GetRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct GetResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::protobuf::SingularPtrField<KeyError>,
pub value: ::std::vec::Vec<u8>,
pub not_found: bool,
pub exec_details_v2: ::protobuf::SingularPtrField<ExecDetailsV2>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a GetResponse {
fn default() -> &'a GetResponse {
<GetResponse as ::protobuf::Message>::default_instance()
}
}
impl GetResponse {
pub fn new() -> GetResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &KeyError {
self.error.as_ref().unwrap_or_else(|| KeyError::default_instance())
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn has_error(&self) -> bool {
self.error.is_some()
}
pub fn set_error(&mut self, v: KeyError) {
self.error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_error(&mut self) -> &mut KeyError {
if self.error.is_none() {
self.error.set_default();
}
self.error.as_mut().unwrap()
}
pub fn take_error(&mut self) -> KeyError {
self.error.take().unwrap_or_else(|| KeyError::new())
}
pub fn get_value(&self) -> &[u8] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::std::vec::Vec<u8>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.value
}
pub fn take_value(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.value, ::std::vec::Vec::new())
}
pub fn get_not_found(&self) -> bool {
self.not_found
}
pub fn clear_not_found(&mut self) {
self.not_found = false;
}
pub fn set_not_found(&mut self, v: bool) {
self.not_found = v;
}
pub fn get_exec_details_v2(&self) -> &ExecDetailsV2 {
self.exec_details_v2.as_ref().unwrap_or_else(|| ExecDetailsV2::default_instance())
}
pub fn clear_exec_details_v2(&mut self) {
self.exec_details_v2.clear();
}
pub fn has_exec_details_v2(&self) -> bool {
self.exec_details_v2.is_some()
}
pub fn set_exec_details_v2(&mut self, v: ExecDetailsV2) {
self.exec_details_v2 = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_exec_details_v2(&mut self) -> &mut ExecDetailsV2 {
if self.exec_details_v2.is_none() {
self.exec_details_v2.set_default();
}
self.exec_details_v2.as_mut().unwrap()
}
pub fn take_exec_details_v2(&mut self) -> ExecDetailsV2 {
self.exec_details_v2.take().unwrap_or_else(|| ExecDetailsV2::new())
}
}
impl ::protobuf::Message for GetResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.error {
if !v.is_initialized() {
return false;
}
};
for v in &self.exec_details_v2 {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.error)?;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.not_found = tmp;
},
6 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.exec_details_v2)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.value.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.value);
}
if self.not_found != false {
my_size += 2;
}
if let Some(ref v) = self.exec_details_v2.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.error.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.value.is_empty() {
os.write_bytes(3, &self.value)?;
}
if self.not_found != false {
os.write_bool(4, self.not_found)?;
}
if let Some(ref v) = self.exec_details_v2.as_ref() {
os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> GetResponse {
GetResponse::new()
}
fn default_instance() -> &'static GetResponse {
static mut instance: ::protobuf::lazy::Lazy<GetResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const GetResponse,
};
unsafe {
instance.get(GetResponse::new)
}
}
}
impl ::protobuf::Clear for GetResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.value.clear();
self.not_found = false;
self.exec_details_v2.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for GetResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
::protobuf::PbPrint::fmt(&self.value, "value", buf);
::protobuf::PbPrint::fmt(&self.not_found, "not_found", buf);
::protobuf::PbPrint::fmt(&self.exec_details_v2, "exec_details_v2", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for GetResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
::protobuf::PbPrint::fmt(&self.value, "value", &mut s);
::protobuf::PbPrint::fmt(&self.not_found, "not_found", &mut s);
::protobuf::PbPrint::fmt(&self.exec_details_v2, "exec_details_v2", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for GetResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ScanRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub start_key: ::std::vec::Vec<u8>,
pub limit: u32,
pub version: u64,
pub key_only: bool,
pub reverse: bool,
pub end_key: ::std::vec::Vec<u8>,
pub sample_step: u32,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ScanRequest {
fn default() -> &'a ScanRequest {
<ScanRequest as ::protobuf::Message>::default_instance()
}
}
impl ScanRequest {
pub fn new() -> ScanRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_start_key(&self) -> &[u8] {
&self.start_key
}
pub fn clear_start_key(&mut self) {
self.start_key.clear();
}
pub fn set_start_key(&mut self, v: ::std::vec::Vec<u8>) {
self.start_key = v;
}
pub fn mut_start_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.start_key
}
pub fn take_start_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.start_key, ::std::vec::Vec::new())
}
pub fn get_limit(&self) -> u32 {
self.limit
}
pub fn clear_limit(&mut self) {
self.limit = 0;
}
pub fn set_limit(&mut self, v: u32) {
self.limit = v;
}
pub fn get_version(&self) -> u64 {
self.version
}
pub fn clear_version(&mut self) {
self.version = 0;
}
pub fn set_version(&mut self, v: u64) {
self.version = v;
}
pub fn get_key_only(&self) -> bool {
self.key_only
}
pub fn clear_key_only(&mut self) {
self.key_only = false;
}
pub fn set_key_only(&mut self, v: bool) {
self.key_only = v;
}
pub fn get_reverse(&self) -> bool {
self.reverse
}
pub fn clear_reverse(&mut self) {
self.reverse = false;
}
pub fn set_reverse(&mut self, v: bool) {
self.reverse = v;
}
pub fn get_end_key(&self) -> &[u8] {
&self.end_key
}
pub fn clear_end_key(&mut self) {
self.end_key.clear();
}
pub fn set_end_key(&mut self, v: ::std::vec::Vec<u8>) {
self.end_key = v;
}
pub fn mut_end_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.end_key
}
pub fn take_end_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.end_key, ::std::vec::Vec::new())
}
pub fn get_sample_step(&self) -> u32 {
self.sample_step
}
pub fn clear_sample_step(&mut self) {
self.sample_step = 0;
}
pub fn set_sample_step(&mut self, v: u32) {
self.sample_step = v;
}
}
impl ::protobuf::Message for ScanRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.start_key)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.limit = tmp;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.version = tmp;
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.key_only = tmp;
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.reverse = tmp;
},
7 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.end_key)?;
},
8 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.sample_step = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.start_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.start_key);
}
if self.limit != 0 {
my_size += ::protobuf::rt::value_size(3, self.limit, ::protobuf::wire_format::WireTypeVarint);
}
if self.version != 0 {
my_size += ::protobuf::rt::value_size(4, self.version, ::protobuf::wire_format::WireTypeVarint);
}
if self.key_only != false {
my_size += 2;
}
if self.reverse != false {
my_size += 2;
}
if !self.end_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(7, &self.end_key);
}
if self.sample_step != 0 {
my_size += ::protobuf::rt::value_size(8, self.sample_step, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.start_key.is_empty() {
os.write_bytes(2, &self.start_key)?;
}
if self.limit != 0 {
os.write_uint32(3, self.limit)?;
}
if self.version != 0 {
os.write_uint64(4, self.version)?;
}
if self.key_only != false {
os.write_bool(5, self.key_only)?;
}
if self.reverse != false {
os.write_bool(6, self.reverse)?;
}
if !self.end_key.is_empty() {
os.write_bytes(7, &self.end_key)?;
}
if self.sample_step != 0 {
os.write_uint32(8, self.sample_step)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ScanRequest {
ScanRequest::new()
}
fn default_instance() -> &'static ScanRequest {
static mut instance: ::protobuf::lazy::Lazy<ScanRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ScanRequest,
};
unsafe {
instance.get(ScanRequest::new)
}
}
}
impl ::protobuf::Clear for ScanRequest {
fn clear(&mut self) {
self.context.clear();
self.start_key.clear();
self.limit = 0;
self.version = 0;
self.key_only = false;
self.reverse = false;
self.end_key.clear();
self.sample_step = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for ScanRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.start_key, "start_key", buf);
::protobuf::PbPrint::fmt(&self.limit, "limit", buf);
::protobuf::PbPrint::fmt(&self.version, "version", buf);
::protobuf::PbPrint::fmt(&self.key_only, "key_only", buf);
::protobuf::PbPrint::fmt(&self.reverse, "reverse", buf);
::protobuf::PbPrint::fmt(&self.end_key, "end_key", buf);
::protobuf::PbPrint::fmt(&self.sample_step, "sample_step", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for ScanRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.start_key, "start_key", &mut s);
::protobuf::PbPrint::fmt(&self.limit, "limit", &mut s);
::protobuf::PbPrint::fmt(&self.version, "version", &mut s);
::protobuf::PbPrint::fmt(&self.key_only, "key_only", &mut s);
::protobuf::PbPrint::fmt(&self.reverse, "reverse", &mut s);
::protobuf::PbPrint::fmt(&self.end_key, "end_key", &mut s);
::protobuf::PbPrint::fmt(&self.sample_step, "sample_step", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for ScanRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ScanResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub pairs: ::protobuf::RepeatedField<KvPair>,
pub error: ::protobuf::SingularPtrField<KeyError>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ScanResponse {
fn default() -> &'a ScanResponse {
<ScanResponse as ::protobuf::Message>::default_instance()
}
}
impl ScanResponse {
pub fn new() -> ScanResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_pairs(&self) -> &[KvPair] {
&self.pairs
}
pub fn clear_pairs(&mut self) {
self.pairs.clear();
}
pub fn set_pairs(&mut self, v: ::protobuf::RepeatedField<KvPair>) {
self.pairs = v;
}
pub fn mut_pairs(&mut self) -> &mut ::protobuf::RepeatedField<KvPair> {
&mut self.pairs
}
pub fn take_pairs(&mut self) -> ::protobuf::RepeatedField<KvPair> {
::std::mem::replace(&mut self.pairs, ::protobuf::RepeatedField::new())
}
pub fn get_error(&self) -> &KeyError {
self.error.as_ref().unwrap_or_else(|| KeyError::default_instance())
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn has_error(&self) -> bool {
self.error.is_some()
}
pub fn set_error(&mut self, v: KeyError) {
self.error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_error(&mut self) -> &mut KeyError {
if self.error.is_none() {
self.error.set_default();
}
self.error.as_mut().unwrap()
}
pub fn take_error(&mut self) -> KeyError {
self.error.take().unwrap_or_else(|| KeyError::new())
}
}
impl ::protobuf::Message for ScanResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.pairs {
if !v.is_initialized() {
return false;
}
};
for v in &self.error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.pairs)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.pairs {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if let Some(ref v) = self.error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.pairs {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
if let Some(ref v) = self.error.as_ref() {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ScanResponse {
ScanResponse::new()
}
fn default_instance() -> &'static ScanResponse {
static mut instance: ::protobuf::lazy::Lazy<ScanResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ScanResponse,
};
unsafe {
instance.get(ScanResponse::new)
}
}
}
impl ::protobuf::Clear for ScanResponse {
fn clear(&mut self) {
self.region_error.clear();
self.pairs.clear();
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for ScanResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.pairs, "pairs", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for ScanResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.pairs, "pairs", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for ScanResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct PrewriteRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub mutations: ::protobuf::RepeatedField<Mutation>,
pub primary_lock: ::std::vec::Vec<u8>,
pub start_version: u64,
pub lock_ttl: u64,
pub skip_constraint_check: bool,
pub is_pessimistic_lock: ::std::vec::Vec<bool>,
pub txn_size: u64,
pub for_update_ts: u64,
pub min_commit_ts: u64,
pub use_async_commit: bool,
pub secondaries: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
pub try_one_pc: bool,
pub max_commit_ts: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a PrewriteRequest {
fn default() -> &'a PrewriteRequest {
<PrewriteRequest as ::protobuf::Message>::default_instance()
}
}
impl PrewriteRequest {
pub fn new() -> PrewriteRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_mutations(&self) -> &[Mutation] {
&self.mutations
}
pub fn clear_mutations(&mut self) {
self.mutations.clear();
}
pub fn set_mutations(&mut self, v: ::protobuf::RepeatedField<Mutation>) {
self.mutations = v;
}
pub fn mut_mutations(&mut self) -> &mut ::protobuf::RepeatedField<Mutation> {
&mut self.mutations
}
pub fn take_mutations(&mut self) -> ::protobuf::RepeatedField<Mutation> {
::std::mem::replace(&mut self.mutations, ::protobuf::RepeatedField::new())
}
pub fn get_primary_lock(&self) -> &[u8] {
&self.primary_lock
}
pub fn clear_primary_lock(&mut self) {
self.primary_lock.clear();
}
pub fn set_primary_lock(&mut self, v: ::std::vec::Vec<u8>) {
self.primary_lock = v;
}
pub fn mut_primary_lock(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.primary_lock
}
pub fn take_primary_lock(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.primary_lock, ::std::vec::Vec::new())
}
pub fn get_start_version(&self) -> u64 {
self.start_version
}
pub fn clear_start_version(&mut self) {
self.start_version = 0;
}
pub fn set_start_version(&mut self, v: u64) {
self.start_version = v;
}
pub fn get_lock_ttl(&self) -> u64 {
self.lock_ttl
}
pub fn clear_lock_ttl(&mut self) {
self.lock_ttl = 0;
}
pub fn set_lock_ttl(&mut self, v: u64) {
self.lock_ttl = v;
}
pub fn get_skip_constraint_check(&self) -> bool {
self.skip_constraint_check
}
pub fn clear_skip_constraint_check(&mut self) {
self.skip_constraint_check = false;
}
pub fn set_skip_constraint_check(&mut self, v: bool) {
self.skip_constraint_check = v;
}
pub fn get_is_pessimistic_lock(&self) -> &[bool] {
&self.is_pessimistic_lock
}
pub fn clear_is_pessimistic_lock(&mut self) {
self.is_pessimistic_lock.clear();
}
pub fn set_is_pessimistic_lock(&mut self, v: ::std::vec::Vec<bool>) {
self.is_pessimistic_lock = v;
}
pub fn mut_is_pessimistic_lock(&mut self) -> &mut ::std::vec::Vec<bool> {
&mut self.is_pessimistic_lock
}
pub fn take_is_pessimistic_lock(&mut self) -> ::std::vec::Vec<bool> {
::std::mem::replace(&mut self.is_pessimistic_lock, ::std::vec::Vec::new())
}
pub fn get_txn_size(&self) -> u64 {
self.txn_size
}
pub fn clear_txn_size(&mut self) {
self.txn_size = 0;
}
pub fn set_txn_size(&mut self, v: u64) {
self.txn_size = v;
}
pub fn get_for_update_ts(&self) -> u64 {
self.for_update_ts
}
pub fn clear_for_update_ts(&mut self) {
self.for_update_ts = 0;
}
pub fn set_for_update_ts(&mut self, v: u64) {
self.for_update_ts = v;
}
pub fn get_min_commit_ts(&self) -> u64 {
self.min_commit_ts
}
pub fn clear_min_commit_ts(&mut self) {
self.min_commit_ts = 0;
}
pub fn set_min_commit_ts(&mut self, v: u64) {
self.min_commit_ts = v;
}
pub fn get_use_async_commit(&self) -> bool {
self.use_async_commit
}
pub fn clear_use_async_commit(&mut self) {
self.use_async_commit = false;
}
pub fn set_use_async_commit(&mut self, v: bool) {
self.use_async_commit = v;
}
pub fn get_secondaries(&self) -> &[::std::vec::Vec<u8>] {
&self.secondaries
}
pub fn clear_secondaries(&mut self) {
self.secondaries.clear();
}
pub fn set_secondaries(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
self.secondaries = v;
}
pub fn mut_secondaries(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
&mut self.secondaries
}
pub fn take_secondaries(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
::std::mem::replace(&mut self.secondaries, ::protobuf::RepeatedField::new())
}
pub fn get_try_one_pc(&self) -> bool {
self.try_one_pc
}
pub fn clear_try_one_pc(&mut self) {
self.try_one_pc = false;
}
pub fn set_try_one_pc(&mut self, v: bool) {
self.try_one_pc = v;
}
pub fn get_max_commit_ts(&self) -> u64 {
self.max_commit_ts
}
pub fn clear_max_commit_ts(&mut self) {
self.max_commit_ts = 0;
}
pub fn set_max_commit_ts(&mut self, v: u64) {
self.max_commit_ts = v;
}
}
impl ::protobuf::Message for PrewriteRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
for v in &self.mutations {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.mutations)?;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.primary_lock)?;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_version = tmp;
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.lock_ttl = tmp;
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.skip_constraint_check = tmp;
},
7 => {
::protobuf::rt::read_repeated_bool_into(wire_type, is, &mut self.is_pessimistic_lock)?;
},
8 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.txn_size = tmp;
},
9 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.for_update_ts = tmp;
},
10 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.min_commit_ts = tmp;
},
11 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.use_async_commit = tmp;
},
12 => {
::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.secondaries)?;
},
13 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.try_one_pc = tmp;
},
14 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.max_commit_ts = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.mutations {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if !self.primary_lock.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.primary_lock);
}
if self.start_version != 0 {
my_size += ::protobuf::rt::value_size(4, self.start_version, ::protobuf::wire_format::WireTypeVarint);
}
if self.lock_ttl != 0 {
my_size += ::protobuf::rt::value_size(5, self.lock_ttl, ::protobuf::wire_format::WireTypeVarint);
}
if self.skip_constraint_check != false {
my_size += 2;
}
my_size += 2 * self.is_pessimistic_lock.len() as u32;
if self.txn_size != 0 {
my_size += ::protobuf::rt::value_size(8, self.txn_size, ::protobuf::wire_format::WireTypeVarint);
}
if self.for_update_ts != 0 {
my_size += ::protobuf::rt::value_size(9, self.for_update_ts, ::protobuf::wire_format::WireTypeVarint);
}
if self.min_commit_ts != 0 {
my_size += ::protobuf::rt::value_size(10, self.min_commit_ts, ::protobuf::wire_format::WireTypeVarint);
}
if self.use_async_commit != false {
my_size += 2;
}
for value in &self.secondaries {
my_size += ::protobuf::rt::bytes_size(12, &value);
};
if self.try_one_pc != false {
my_size += 2;
}
if self.max_commit_ts != 0 {
my_size += ::protobuf::rt::value_size(14, self.max_commit_ts, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.mutations {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
if !self.primary_lock.is_empty() {
os.write_bytes(3, &self.primary_lock)?;
}
if self.start_version != 0 {
os.write_uint64(4, self.start_version)?;
}
if self.lock_ttl != 0 {
os.write_uint64(5, self.lock_ttl)?;
}
if self.skip_constraint_check != false {
os.write_bool(6, self.skip_constraint_check)?;
}
for v in &self.is_pessimistic_lock {
os.write_bool(7, *v)?;
};
if self.txn_size != 0 {
os.write_uint64(8, self.txn_size)?;
}
if self.for_update_ts != 0 {
os.write_uint64(9, self.for_update_ts)?;
}
if self.min_commit_ts != 0 {
os.write_uint64(10, self.min_commit_ts)?;
}
if self.use_async_commit != false {
os.write_bool(11, self.use_async_commit)?;
}
for v in &self.secondaries {
os.write_bytes(12, &v)?;
};
if self.try_one_pc != false {
os.write_bool(13, self.try_one_pc)?;
}
if self.max_commit_ts != 0 {
os.write_uint64(14, self.max_commit_ts)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> PrewriteRequest {
PrewriteRequest::new()
}
fn default_instance() -> &'static PrewriteRequest {
static mut instance: ::protobuf::lazy::Lazy<PrewriteRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const PrewriteRequest,
};
unsafe {
instance.get(PrewriteRequest::new)
}
}
}
impl ::protobuf::Clear for PrewriteRequest {
fn clear(&mut self) {
self.context.clear();
self.mutations.clear();
self.primary_lock.clear();
self.start_version = 0;
self.lock_ttl = 0;
self.skip_constraint_check = false;
self.is_pessimistic_lock.clear();
self.txn_size = 0;
self.for_update_ts = 0;
self.min_commit_ts = 0;
self.use_async_commit = false;
self.secondaries.clear();
self.try_one_pc = false;
self.max_commit_ts = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for PrewriteRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.mutations, "mutations", buf);
::protobuf::PbPrint::fmt(&self.primary_lock, "primary_lock", buf);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", buf);
::protobuf::PbPrint::fmt(&self.lock_ttl, "lock_ttl", buf);
::protobuf::PbPrint::fmt(&self.skip_constraint_check, "skip_constraint_check", buf);
::protobuf::PbPrint::fmt(&self.is_pessimistic_lock, "is_pessimistic_lock", buf);
::protobuf::PbPrint::fmt(&self.txn_size, "txn_size", buf);
::protobuf::PbPrint::fmt(&self.for_update_ts, "for_update_ts", buf);
::protobuf::PbPrint::fmt(&self.min_commit_ts, "min_commit_ts", buf);
::protobuf::PbPrint::fmt(&self.use_async_commit, "use_async_commit", buf);
::protobuf::PbPrint::fmt(&self.secondaries, "secondaries", buf);
::protobuf::PbPrint::fmt(&self.try_one_pc, "try_one_pc", buf);
::protobuf::PbPrint::fmt(&self.max_commit_ts, "max_commit_ts", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for PrewriteRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.mutations, "mutations", &mut s);
::protobuf::PbPrint::fmt(&self.primary_lock, "primary_lock", &mut s);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", &mut s);
::protobuf::PbPrint::fmt(&self.lock_ttl, "lock_ttl", &mut s);
::protobuf::PbPrint::fmt(&self.skip_constraint_check, "skip_constraint_check", &mut s);
::protobuf::PbPrint::fmt(&self.is_pessimistic_lock, "is_pessimistic_lock", &mut s);
::protobuf::PbPrint::fmt(&self.txn_size, "txn_size", &mut s);
::protobuf::PbPrint::fmt(&self.for_update_ts, "for_update_ts", &mut s);
::protobuf::PbPrint::fmt(&self.min_commit_ts, "min_commit_ts", &mut s);
::protobuf::PbPrint::fmt(&self.use_async_commit, "use_async_commit", &mut s);
::protobuf::PbPrint::fmt(&self.secondaries, "secondaries", &mut s);
::protobuf::PbPrint::fmt(&self.try_one_pc, "try_one_pc", &mut s);
::protobuf::PbPrint::fmt(&self.max_commit_ts, "max_commit_ts", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for PrewriteRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct PrewriteResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub errors: ::protobuf::RepeatedField<KeyError>,
pub min_commit_ts: u64,
pub one_pc_commit_ts: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a PrewriteResponse {
fn default() -> &'a PrewriteResponse {
<PrewriteResponse as ::protobuf::Message>::default_instance()
}
}
impl PrewriteResponse {
pub fn new() -> PrewriteResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_errors(&self) -> &[KeyError] {
&self.errors
}
pub fn clear_errors(&mut self) {
self.errors.clear();
}
pub fn set_errors(&mut self, v: ::protobuf::RepeatedField<KeyError>) {
self.errors = v;
}
pub fn mut_errors(&mut self) -> &mut ::protobuf::RepeatedField<KeyError> {
&mut self.errors
}
pub fn take_errors(&mut self) -> ::protobuf::RepeatedField<KeyError> {
::std::mem::replace(&mut self.errors, ::protobuf::RepeatedField::new())
}
pub fn get_min_commit_ts(&self) -> u64 {
self.min_commit_ts
}
pub fn clear_min_commit_ts(&mut self) {
self.min_commit_ts = 0;
}
pub fn set_min_commit_ts(&mut self, v: u64) {
self.min_commit_ts = v;
}
pub fn get_one_pc_commit_ts(&self) -> u64 {
self.one_pc_commit_ts
}
pub fn clear_one_pc_commit_ts(&mut self) {
self.one_pc_commit_ts = 0;
}
pub fn set_one_pc_commit_ts(&mut self, v: u64) {
self.one_pc_commit_ts = v;
}
}
impl ::protobuf::Message for PrewriteResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.errors {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.errors)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.min_commit_ts = tmp;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.one_pc_commit_ts = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.errors {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if self.min_commit_ts != 0 {
my_size += ::protobuf::rt::value_size(3, self.min_commit_ts, ::protobuf::wire_format::WireTypeVarint);
}
if self.one_pc_commit_ts != 0 {
my_size += ::protobuf::rt::value_size(4, self.one_pc_commit_ts, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.errors {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
if self.min_commit_ts != 0 {
os.write_uint64(3, self.min_commit_ts)?;
}
if self.one_pc_commit_ts != 0 {
os.write_uint64(4, self.one_pc_commit_ts)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> PrewriteResponse {
PrewriteResponse::new()
}
fn default_instance() -> &'static PrewriteResponse {
static mut instance: ::protobuf::lazy::Lazy<PrewriteResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const PrewriteResponse,
};
unsafe {
instance.get(PrewriteResponse::new)
}
}
}
impl ::protobuf::Clear for PrewriteResponse {
fn clear(&mut self) {
self.region_error.clear();
self.errors.clear();
self.min_commit_ts = 0;
self.one_pc_commit_ts = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for PrewriteResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.errors, "errors", buf);
::protobuf::PbPrint::fmt(&self.min_commit_ts, "min_commit_ts", buf);
::protobuf::PbPrint::fmt(&self.one_pc_commit_ts, "one_pc_commit_ts", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for PrewriteResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.errors, "errors", &mut s);
::protobuf::PbPrint::fmt(&self.min_commit_ts, "min_commit_ts", &mut s);
::protobuf::PbPrint::fmt(&self.one_pc_commit_ts, "one_pc_commit_ts", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for PrewriteResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct PessimisticLockRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub mutations: ::protobuf::RepeatedField<Mutation>,
pub primary_lock: ::std::vec::Vec<u8>,
pub start_version: u64,
pub lock_ttl: u64,
pub for_update_ts: u64,
pub is_first_lock: bool,
pub wait_timeout: i64,
pub force: bool,
pub return_values: bool,
pub min_commit_ts: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a PessimisticLockRequest {
fn default() -> &'a PessimisticLockRequest {
<PessimisticLockRequest as ::protobuf::Message>::default_instance()
}
}
impl PessimisticLockRequest {
pub fn new() -> PessimisticLockRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_mutations(&self) -> &[Mutation] {
&self.mutations
}
pub fn clear_mutations(&mut self) {
self.mutations.clear();
}
pub fn set_mutations(&mut self, v: ::protobuf::RepeatedField<Mutation>) {
self.mutations = v;
}
pub fn mut_mutations(&mut self) -> &mut ::protobuf::RepeatedField<Mutation> {
&mut self.mutations
}
pub fn take_mutations(&mut self) -> ::protobuf::RepeatedField<Mutation> {
::std::mem::replace(&mut self.mutations, ::protobuf::RepeatedField::new())
}
pub fn get_primary_lock(&self) -> &[u8] {
&self.primary_lock
}
pub fn clear_primary_lock(&mut self) {
self.primary_lock.clear();
}
pub fn set_primary_lock(&mut self, v: ::std::vec::Vec<u8>) {
self.primary_lock = v;
}
pub fn mut_primary_lock(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.primary_lock
}
pub fn take_primary_lock(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.primary_lock, ::std::vec::Vec::new())
}
pub fn get_start_version(&self) -> u64 {
self.start_version
}
pub fn clear_start_version(&mut self) {
self.start_version = 0;
}
pub fn set_start_version(&mut self, v: u64) {
self.start_version = v;
}
pub fn get_lock_ttl(&self) -> u64 {
self.lock_ttl
}
pub fn clear_lock_ttl(&mut self) {
self.lock_ttl = 0;
}
pub fn set_lock_ttl(&mut self, v: u64) {
self.lock_ttl = v;
}
pub fn get_for_update_ts(&self) -> u64 {
self.for_update_ts
}
pub fn clear_for_update_ts(&mut self) {
self.for_update_ts = 0;
}
pub fn set_for_update_ts(&mut self, v: u64) {
self.for_update_ts = v;
}
pub fn get_is_first_lock(&self) -> bool {
self.is_first_lock
}
pub fn clear_is_first_lock(&mut self) {
self.is_first_lock = false;
}
pub fn set_is_first_lock(&mut self, v: bool) {
self.is_first_lock = v;
}
pub fn get_wait_timeout(&self) -> i64 {
self.wait_timeout
}
pub fn clear_wait_timeout(&mut self) {
self.wait_timeout = 0;
}
pub fn set_wait_timeout(&mut self, v: i64) {
self.wait_timeout = v;
}
pub fn get_force(&self) -> bool {
self.force
}
pub fn clear_force(&mut self) {
self.force = false;
}
pub fn set_force(&mut self, v: bool) {
self.force = v;
}
pub fn get_return_values(&self) -> bool {
self.return_values
}
pub fn clear_return_values(&mut self) {
self.return_values = false;
}
pub fn set_return_values(&mut self, v: bool) {
self.return_values = v;
}
pub fn get_min_commit_ts(&self) -> u64 {
self.min_commit_ts
}
pub fn clear_min_commit_ts(&mut self) {
self.min_commit_ts = 0;
}
pub fn set_min_commit_ts(&mut self, v: u64) {
self.min_commit_ts = v;
}
}
impl ::protobuf::Message for PessimisticLockRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
for v in &self.mutations {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.mutations)?;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.primary_lock)?;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_version = tmp;
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.lock_ttl = tmp;
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.for_update_ts = tmp;
},
7 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.is_first_lock = tmp;
},
8 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_int64()?;
self.wait_timeout = tmp;
},
9 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.force = tmp;
},
10 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.return_values = tmp;
},
11 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.min_commit_ts = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.mutations {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if !self.primary_lock.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.primary_lock);
}
if self.start_version != 0 {
my_size += ::protobuf::rt::value_size(4, self.start_version, ::protobuf::wire_format::WireTypeVarint);
}
if self.lock_ttl != 0 {
my_size += ::protobuf::rt::value_size(5, self.lock_ttl, ::protobuf::wire_format::WireTypeVarint);
}
if self.for_update_ts != 0 {
my_size += ::protobuf::rt::value_size(6, self.for_update_ts, ::protobuf::wire_format::WireTypeVarint);
}
if self.is_first_lock != false {
my_size += 2;
}
if self.wait_timeout != 0 {
my_size += ::protobuf::rt::value_size(8, self.wait_timeout, ::protobuf::wire_format::WireTypeVarint);
}
if self.force != false {
my_size += 2;
}
if self.return_values != false {
my_size += 2;
}
if self.min_commit_ts != 0 {
my_size += ::protobuf::rt::value_size(11, self.min_commit_ts, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.mutations {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
if !self.primary_lock.is_empty() {
os.write_bytes(3, &self.primary_lock)?;
}
if self.start_version != 0 {
os.write_uint64(4, self.start_version)?;
}
if self.lock_ttl != 0 {
os.write_uint64(5, self.lock_ttl)?;
}
if self.for_update_ts != 0 {
os.write_uint64(6, self.for_update_ts)?;
}
if self.is_first_lock != false {
os.write_bool(7, self.is_first_lock)?;
}
if self.wait_timeout != 0 {
os.write_int64(8, self.wait_timeout)?;
}
if self.force != false {
os.write_bool(9, self.force)?;
}
if self.return_values != false {
os.write_bool(10, self.return_values)?;
}
if self.min_commit_ts != 0 {
os.write_uint64(11, self.min_commit_ts)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> PessimisticLockRequest {
PessimisticLockRequest::new()
}
fn default_instance() -> &'static PessimisticLockRequest {
static mut instance: ::protobuf::lazy::Lazy<PessimisticLockRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const PessimisticLockRequest,
};
unsafe {
instance.get(PessimisticLockRequest::new)
}
}
}
impl ::protobuf::Clear for PessimisticLockRequest {
fn clear(&mut self) {
self.context.clear();
self.mutations.clear();
self.primary_lock.clear();
self.start_version = 0;
self.lock_ttl = 0;
self.for_update_ts = 0;
self.is_first_lock = false;
self.wait_timeout = 0;
self.force = false;
self.return_values = false;
self.min_commit_ts = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for PessimisticLockRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.mutations, "mutations", buf);
::protobuf::PbPrint::fmt(&self.primary_lock, "primary_lock", buf);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", buf);
::protobuf::PbPrint::fmt(&self.lock_ttl, "lock_ttl", buf);
::protobuf::PbPrint::fmt(&self.for_update_ts, "for_update_ts", buf);
::protobuf::PbPrint::fmt(&self.is_first_lock, "is_first_lock", buf);
::protobuf::PbPrint::fmt(&self.wait_timeout, "wait_timeout", buf);
::protobuf::PbPrint::fmt(&self.force, "force", buf);
::protobuf::PbPrint::fmt(&self.return_values, "return_values", buf);
::protobuf::PbPrint::fmt(&self.min_commit_ts, "min_commit_ts", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for PessimisticLockRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.mutations, "mutations", &mut s);
::protobuf::PbPrint::fmt(&self.primary_lock, "primary_lock", &mut s);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", &mut s);
::protobuf::PbPrint::fmt(&self.lock_ttl, "lock_ttl", &mut s);
::protobuf::PbPrint::fmt(&self.for_update_ts, "for_update_ts", &mut s);
::protobuf::PbPrint::fmt(&self.is_first_lock, "is_first_lock", &mut s);
::protobuf::PbPrint::fmt(&self.wait_timeout, "wait_timeout", &mut s);
::protobuf::PbPrint::fmt(&self.force, "force", &mut s);
::protobuf::PbPrint::fmt(&self.return_values, "return_values", &mut s);
::protobuf::PbPrint::fmt(&self.min_commit_ts, "min_commit_ts", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for PessimisticLockRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct PessimisticLockResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub errors: ::protobuf::RepeatedField<KeyError>,
pub commit_ts: u64,
pub value: ::std::vec::Vec<u8>,
pub values: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a PessimisticLockResponse {
fn default() -> &'a PessimisticLockResponse {
<PessimisticLockResponse as ::protobuf::Message>::default_instance()
}
}
impl PessimisticLockResponse {
pub fn new() -> PessimisticLockResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_errors(&self) -> &[KeyError] {
&self.errors
}
pub fn clear_errors(&mut self) {
self.errors.clear();
}
pub fn set_errors(&mut self, v: ::protobuf::RepeatedField<KeyError>) {
self.errors = v;
}
pub fn mut_errors(&mut self) -> &mut ::protobuf::RepeatedField<KeyError> {
&mut self.errors
}
pub fn take_errors(&mut self) -> ::protobuf::RepeatedField<KeyError> {
::std::mem::replace(&mut self.errors, ::protobuf::RepeatedField::new())
}
pub fn get_commit_ts(&self) -> u64 {
self.commit_ts
}
pub fn clear_commit_ts(&mut self) {
self.commit_ts = 0;
}
pub fn set_commit_ts(&mut self, v: u64) {
self.commit_ts = v;
}
pub fn get_value(&self) -> &[u8] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::std::vec::Vec<u8>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.value
}
pub fn take_value(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.value, ::std::vec::Vec::new())
}
pub fn get_values(&self) -> &[::std::vec::Vec<u8>] {
&self.values
}
pub fn clear_values(&mut self) {
self.values.clear();
}
pub fn set_values(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
self.values = v;
}
pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
&mut self.values
}
pub fn take_values(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
::std::mem::replace(&mut self.values, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for PessimisticLockResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.errors {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.errors)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.commit_ts = tmp;
},
4 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
},
5 => {
::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.values)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.errors {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if self.commit_ts != 0 {
my_size += ::protobuf::rt::value_size(3, self.commit_ts, ::protobuf::wire_format::WireTypeVarint);
}
if !self.value.is_empty() {
my_size += ::protobuf::rt::bytes_size(4, &self.value);
}
for value in &self.values {
my_size += ::protobuf::rt::bytes_size(5, &value);
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.errors {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
if self.commit_ts != 0 {
os.write_uint64(3, self.commit_ts)?;
}
if !self.value.is_empty() {
os.write_bytes(4, &self.value)?;
}
for v in &self.values {
os.write_bytes(5, &v)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> PessimisticLockResponse {
PessimisticLockResponse::new()
}
fn default_instance() -> &'static PessimisticLockResponse {
static mut instance: ::protobuf::lazy::Lazy<PessimisticLockResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const PessimisticLockResponse,
};
unsafe {
instance.get(PessimisticLockResponse::new)
}
}
}
impl ::protobuf::Clear for PessimisticLockResponse {
fn clear(&mut self) {
self.region_error.clear();
self.errors.clear();
self.commit_ts = 0;
self.value.clear();
self.values.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for PessimisticLockResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.errors, "errors", buf);
::protobuf::PbPrint::fmt(&self.commit_ts, "commit_ts", buf);
::protobuf::PbPrint::fmt(&self.value, "value", buf);
::protobuf::PbPrint::fmt(&self.values, "values", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for PessimisticLockResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.errors, "errors", &mut s);
::protobuf::PbPrint::fmt(&self.commit_ts, "commit_ts", &mut s);
::protobuf::PbPrint::fmt(&self.value, "value", &mut s);
::protobuf::PbPrint::fmt(&self.values, "values", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for PessimisticLockResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct PessimisticRollbackRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub start_version: u64,
pub for_update_ts: u64,
pub keys: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a PessimisticRollbackRequest {
fn default() -> &'a PessimisticRollbackRequest {
<PessimisticRollbackRequest as ::protobuf::Message>::default_instance()
}
}
impl PessimisticRollbackRequest {
pub fn new() -> PessimisticRollbackRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_start_version(&self) -> u64 {
self.start_version
}
pub fn clear_start_version(&mut self) {
self.start_version = 0;
}
pub fn set_start_version(&mut self, v: u64) {
self.start_version = v;
}
pub fn get_for_update_ts(&self) -> u64 {
self.for_update_ts
}
pub fn clear_for_update_ts(&mut self) {
self.for_update_ts = 0;
}
pub fn set_for_update_ts(&mut self, v: u64) {
self.for_update_ts = v;
}
pub fn get_keys(&self) -> &[::std::vec::Vec<u8>] {
&self.keys
}
pub fn clear_keys(&mut self) {
self.keys.clear();
}
pub fn set_keys(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
self.keys = v;
}
pub fn mut_keys(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
&mut self.keys
}
pub fn take_keys(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
::std::mem::replace(&mut self.keys, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for PessimisticRollbackRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_version = tmp;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.for_update_ts = tmp;
},
4 => {
::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.keys)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.start_version != 0 {
my_size += ::protobuf::rt::value_size(2, self.start_version, ::protobuf::wire_format::WireTypeVarint);
}
if self.for_update_ts != 0 {
my_size += ::protobuf::rt::value_size(3, self.for_update_ts, ::protobuf::wire_format::WireTypeVarint);
}
for value in &self.keys {
my_size += ::protobuf::rt::bytes_size(4, &value);
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.start_version != 0 {
os.write_uint64(2, self.start_version)?;
}
if self.for_update_ts != 0 {
os.write_uint64(3, self.for_update_ts)?;
}
for v in &self.keys {
os.write_bytes(4, &v)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> PessimisticRollbackRequest {
PessimisticRollbackRequest::new()
}
fn default_instance() -> &'static PessimisticRollbackRequest {
static mut instance: ::protobuf::lazy::Lazy<PessimisticRollbackRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const PessimisticRollbackRequest,
};
unsafe {
instance.get(PessimisticRollbackRequest::new)
}
}
}
impl ::protobuf::Clear for PessimisticRollbackRequest {
fn clear(&mut self) {
self.context.clear();
self.start_version = 0;
self.for_update_ts = 0;
self.keys.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for PessimisticRollbackRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", buf);
::protobuf::PbPrint::fmt(&self.for_update_ts, "for_update_ts", buf);
::protobuf::PbPrint::fmt(&self.keys, "keys", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for PessimisticRollbackRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", &mut s);
::protobuf::PbPrint::fmt(&self.for_update_ts, "for_update_ts", &mut s);
::protobuf::PbPrint::fmt(&self.keys, "keys", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for PessimisticRollbackRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct PessimisticRollbackResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub errors: ::protobuf::RepeatedField<KeyError>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a PessimisticRollbackResponse {
fn default() -> &'a PessimisticRollbackResponse {
<PessimisticRollbackResponse as ::protobuf::Message>::default_instance()
}
}
impl PessimisticRollbackResponse {
pub fn new() -> PessimisticRollbackResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_errors(&self) -> &[KeyError] {
&self.errors
}
pub fn clear_errors(&mut self) {
self.errors.clear();
}
pub fn set_errors(&mut self, v: ::protobuf::RepeatedField<KeyError>) {
self.errors = v;
}
pub fn mut_errors(&mut self) -> &mut ::protobuf::RepeatedField<KeyError> {
&mut self.errors
}
pub fn take_errors(&mut self) -> ::protobuf::RepeatedField<KeyError> {
::std::mem::replace(&mut self.errors, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for PessimisticRollbackResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.errors {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.errors)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.errors {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.errors {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> PessimisticRollbackResponse {
PessimisticRollbackResponse::new()
}
fn default_instance() -> &'static PessimisticRollbackResponse {
static mut instance: ::protobuf::lazy::Lazy<PessimisticRollbackResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const PessimisticRollbackResponse,
};
unsafe {
instance.get(PessimisticRollbackResponse::new)
}
}
}
impl ::protobuf::Clear for PessimisticRollbackResponse {
fn clear(&mut self) {
self.region_error.clear();
self.errors.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for PessimisticRollbackResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.errors, "errors", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for PessimisticRollbackResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.errors, "errors", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for PessimisticRollbackResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxnHeartBeatRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub primary_lock: ::std::vec::Vec<u8>,
pub start_version: u64,
pub advise_lock_ttl: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxnHeartBeatRequest {
fn default() -> &'a TxnHeartBeatRequest {
<TxnHeartBeatRequest as ::protobuf::Message>::default_instance()
}
}
impl TxnHeartBeatRequest {
pub fn new() -> TxnHeartBeatRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_primary_lock(&self) -> &[u8] {
&self.primary_lock
}
pub fn clear_primary_lock(&mut self) {
self.primary_lock.clear();
}
pub fn set_primary_lock(&mut self, v: ::std::vec::Vec<u8>) {
self.primary_lock = v;
}
pub fn mut_primary_lock(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.primary_lock
}
pub fn take_primary_lock(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.primary_lock, ::std::vec::Vec::new())
}
pub fn get_start_version(&self) -> u64 {
self.start_version
}
pub fn clear_start_version(&mut self) {
self.start_version = 0;
}
pub fn set_start_version(&mut self, v: u64) {
self.start_version = v;
}
pub fn get_advise_lock_ttl(&self) -> u64 {
self.advise_lock_ttl
}
pub fn clear_advise_lock_ttl(&mut self) {
self.advise_lock_ttl = 0;
}
pub fn set_advise_lock_ttl(&mut self, v: u64) {
self.advise_lock_ttl = v;
}
}
impl ::protobuf::Message for TxnHeartBeatRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.primary_lock)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_version = tmp;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.advise_lock_ttl = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.primary_lock.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.primary_lock);
}
if self.start_version != 0 {
my_size += ::protobuf::rt::value_size(3, self.start_version, ::protobuf::wire_format::WireTypeVarint);
}
if self.advise_lock_ttl != 0 {
my_size += ::protobuf::rt::value_size(4, self.advise_lock_ttl, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.primary_lock.is_empty() {
os.write_bytes(2, &self.primary_lock)?;
}
if self.start_version != 0 {
os.write_uint64(3, self.start_version)?;
}
if self.advise_lock_ttl != 0 {
os.write_uint64(4, self.advise_lock_ttl)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> TxnHeartBeatRequest {
TxnHeartBeatRequest::new()
}
fn default_instance() -> &'static TxnHeartBeatRequest {
static mut instance: ::protobuf::lazy::Lazy<TxnHeartBeatRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const TxnHeartBeatRequest,
};
unsafe {
instance.get(TxnHeartBeatRequest::new)
}
}
}
impl ::protobuf::Clear for TxnHeartBeatRequest {
fn clear(&mut self) {
self.context.clear();
self.primary_lock.clear();
self.start_version = 0;
self.advise_lock_ttl = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for TxnHeartBeatRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.primary_lock, "primary_lock", buf);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", buf);
::protobuf::PbPrint::fmt(&self.advise_lock_ttl, "advise_lock_ttl", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for TxnHeartBeatRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.primary_lock, "primary_lock", &mut s);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", &mut s);
::protobuf::PbPrint::fmt(&self.advise_lock_ttl, "advise_lock_ttl", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for TxnHeartBeatRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxnHeartBeatResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::protobuf::SingularPtrField<KeyError>,
pub lock_ttl: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxnHeartBeatResponse {
fn default() -> &'a TxnHeartBeatResponse {
<TxnHeartBeatResponse as ::protobuf::Message>::default_instance()
}
}
impl TxnHeartBeatResponse {
pub fn new() -> TxnHeartBeatResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &KeyError {
self.error.as_ref().unwrap_or_else(|| KeyError::default_instance())
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn has_error(&self) -> bool {
self.error.is_some()
}
pub fn set_error(&mut self, v: KeyError) {
self.error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_error(&mut self) -> &mut KeyError {
if self.error.is_none() {
self.error.set_default();
}
self.error.as_mut().unwrap()
}
pub fn take_error(&mut self) -> KeyError {
self.error.take().unwrap_or_else(|| KeyError::new())
}
pub fn get_lock_ttl(&self) -> u64 {
self.lock_ttl
}
pub fn clear_lock_ttl(&mut self) {
self.lock_ttl = 0;
}
pub fn set_lock_ttl(&mut self, v: u64) {
self.lock_ttl = v;
}
}
impl ::protobuf::Message for TxnHeartBeatResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.error)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.lock_ttl = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.lock_ttl != 0 {
my_size += ::protobuf::rt::value_size(3, self.lock_ttl, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.error.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.lock_ttl != 0 {
os.write_uint64(3, self.lock_ttl)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> TxnHeartBeatResponse {
TxnHeartBeatResponse::new()
}
fn default_instance() -> &'static TxnHeartBeatResponse {
static mut instance: ::protobuf::lazy::Lazy<TxnHeartBeatResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const TxnHeartBeatResponse,
};
unsafe {
instance.get(TxnHeartBeatResponse::new)
}
}
}
impl ::protobuf::Clear for TxnHeartBeatResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.lock_ttl = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for TxnHeartBeatResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
::protobuf::PbPrint::fmt(&self.lock_ttl, "lock_ttl", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for TxnHeartBeatResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
::protobuf::PbPrint::fmt(&self.lock_ttl, "lock_ttl", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for TxnHeartBeatResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CheckTxnStatusRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub primary_key: ::std::vec::Vec<u8>,
pub lock_ts: u64,
pub caller_start_ts: u64,
pub current_ts: u64,
pub rollback_if_not_exist: bool,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CheckTxnStatusRequest {
fn default() -> &'a CheckTxnStatusRequest {
<CheckTxnStatusRequest as ::protobuf::Message>::default_instance()
}
}
impl CheckTxnStatusRequest {
pub fn new() -> CheckTxnStatusRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_primary_key(&self) -> &[u8] {
&self.primary_key
}
pub fn clear_primary_key(&mut self) {
self.primary_key.clear();
}
pub fn set_primary_key(&mut self, v: ::std::vec::Vec<u8>) {
self.primary_key = v;
}
pub fn mut_primary_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.primary_key
}
pub fn take_primary_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.primary_key, ::std::vec::Vec::new())
}
pub fn get_lock_ts(&self) -> u64 {
self.lock_ts
}
pub fn clear_lock_ts(&mut self) {
self.lock_ts = 0;
}
pub fn set_lock_ts(&mut self, v: u64) {
self.lock_ts = v;
}
pub fn get_caller_start_ts(&self) -> u64 {
self.caller_start_ts
}
pub fn clear_caller_start_ts(&mut self) {
self.caller_start_ts = 0;
}
pub fn set_caller_start_ts(&mut self, v: u64) {
self.caller_start_ts = v;
}
pub fn get_current_ts(&self) -> u64 {
self.current_ts
}
pub fn clear_current_ts(&mut self) {
self.current_ts = 0;
}
pub fn set_current_ts(&mut self, v: u64) {
self.current_ts = v;
}
pub fn get_rollback_if_not_exist(&self) -> bool {
self.rollback_if_not_exist
}
pub fn clear_rollback_if_not_exist(&mut self) {
self.rollback_if_not_exist = false;
}
pub fn set_rollback_if_not_exist(&mut self, v: bool) {
self.rollback_if_not_exist = v;
}
}
impl ::protobuf::Message for CheckTxnStatusRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.primary_key)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.lock_ts = tmp;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.caller_start_ts = tmp;
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.current_ts = tmp;
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.rollback_if_not_exist = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.primary_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.primary_key);
}
if self.lock_ts != 0 {
my_size += ::protobuf::rt::value_size(3, self.lock_ts, ::protobuf::wire_format::WireTypeVarint);
}
if self.caller_start_ts != 0 {
my_size += ::protobuf::rt::value_size(4, self.caller_start_ts, ::protobuf::wire_format::WireTypeVarint);
}
if self.current_ts != 0 {
my_size += ::protobuf::rt::value_size(5, self.current_ts, ::protobuf::wire_format::WireTypeVarint);
}
if self.rollback_if_not_exist != false {
my_size += 2;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.primary_key.is_empty() {
os.write_bytes(2, &self.primary_key)?;
}
if self.lock_ts != 0 {
os.write_uint64(3, self.lock_ts)?;
}
if self.caller_start_ts != 0 {
os.write_uint64(4, self.caller_start_ts)?;
}
if self.current_ts != 0 {
os.write_uint64(5, self.current_ts)?;
}
if self.rollback_if_not_exist != false {
os.write_bool(6, self.rollback_if_not_exist)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CheckTxnStatusRequest {
CheckTxnStatusRequest::new()
}
fn default_instance() -> &'static CheckTxnStatusRequest {
static mut instance: ::protobuf::lazy::Lazy<CheckTxnStatusRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CheckTxnStatusRequest,
};
unsafe {
instance.get(CheckTxnStatusRequest::new)
}
}
}
impl ::protobuf::Clear for CheckTxnStatusRequest {
fn clear(&mut self) {
self.context.clear();
self.primary_key.clear();
self.lock_ts = 0;
self.caller_start_ts = 0;
self.current_ts = 0;
self.rollback_if_not_exist = false;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for CheckTxnStatusRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.primary_key, "primary_key", buf);
::protobuf::PbPrint::fmt(&self.lock_ts, "lock_ts", buf);
::protobuf::PbPrint::fmt(&self.caller_start_ts, "caller_start_ts", buf);
::protobuf::PbPrint::fmt(&self.current_ts, "current_ts", buf);
::protobuf::PbPrint::fmt(&self.rollback_if_not_exist, "rollback_if_not_exist", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for CheckTxnStatusRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.primary_key, "primary_key", &mut s);
::protobuf::PbPrint::fmt(&self.lock_ts, "lock_ts", &mut s);
::protobuf::PbPrint::fmt(&self.caller_start_ts, "caller_start_ts", &mut s);
::protobuf::PbPrint::fmt(&self.current_ts, "current_ts", &mut s);
::protobuf::PbPrint::fmt(&self.rollback_if_not_exist, "rollback_if_not_exist", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for CheckTxnStatusRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CheckTxnStatusResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::protobuf::SingularPtrField<KeyError>,
pub lock_ttl: u64,
pub commit_version: u64,
pub action: Action,
pub lock_info: ::protobuf::SingularPtrField<LockInfo>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CheckTxnStatusResponse {
fn default() -> &'a CheckTxnStatusResponse {
<CheckTxnStatusResponse as ::protobuf::Message>::default_instance()
}
}
impl CheckTxnStatusResponse {
pub fn new() -> CheckTxnStatusResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &KeyError {
self.error.as_ref().unwrap_or_else(|| KeyError::default_instance())
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn has_error(&self) -> bool {
self.error.is_some()
}
pub fn set_error(&mut self, v: KeyError) {
self.error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_error(&mut self) -> &mut KeyError {
if self.error.is_none() {
self.error.set_default();
}
self.error.as_mut().unwrap()
}
pub fn take_error(&mut self) -> KeyError {
self.error.take().unwrap_or_else(|| KeyError::new())
}
pub fn get_lock_ttl(&self) -> u64 {
self.lock_ttl
}
pub fn clear_lock_ttl(&mut self) {
self.lock_ttl = 0;
}
pub fn set_lock_ttl(&mut self, v: u64) {
self.lock_ttl = v;
}
pub fn get_commit_version(&self) -> u64 {
self.commit_version
}
pub fn clear_commit_version(&mut self) {
self.commit_version = 0;
}
pub fn set_commit_version(&mut self, v: u64) {
self.commit_version = v;
}
pub fn get_action(&self) -> Action {
self.action
}
pub fn clear_action(&mut self) {
self.action = Action::NoAction;
}
pub fn set_action(&mut self, v: Action) {
self.action = v;
}
pub fn get_lock_info(&self) -> &LockInfo {
self.lock_info.as_ref().unwrap_or_else(|| LockInfo::default_instance())
}
pub fn clear_lock_info(&mut self) {
self.lock_info.clear();
}
pub fn has_lock_info(&self) -> bool {
self.lock_info.is_some()
}
pub fn set_lock_info(&mut self, v: LockInfo) {
self.lock_info = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_lock_info(&mut self) -> &mut LockInfo {
if self.lock_info.is_none() {
self.lock_info.set_default();
}
self.lock_info.as_mut().unwrap()
}
pub fn take_lock_info(&mut self) -> LockInfo {
self.lock_info.take().unwrap_or_else(|| LockInfo::new())
}
}
impl ::protobuf::Message for CheckTxnStatusResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.error {
if !v.is_initialized() {
return false;
}
};
for v in &self.lock_info {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.error)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.lock_ttl = tmp;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.commit_version = tmp;
},
5 => {
if wire_type == ::protobuf::wire_format::WireTypeVarint {self.action = is.read_enum()?;} else {return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));}
},
6 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.lock_info)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.lock_ttl != 0 {
my_size += ::protobuf::rt::value_size(3, self.lock_ttl, ::protobuf::wire_format::WireTypeVarint);
}
if self.commit_version != 0 {
my_size += ::protobuf::rt::value_size(4, self.commit_version, ::protobuf::wire_format::WireTypeVarint);
}
if self.action != Action::NoAction {
my_size += ::protobuf::rt::enum_size(5, self.action);
}
if let Some(ref v) = self.lock_info.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.error.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.lock_ttl != 0 {
os.write_uint64(3, self.lock_ttl)?;
}
if self.commit_version != 0 {
os.write_uint64(4, self.commit_version)?;
}
if self.action != Action::NoAction {
os.write_enum(5, self.action.value())?;
}
if let Some(ref v) = self.lock_info.as_ref() {
os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CheckTxnStatusResponse {
CheckTxnStatusResponse::new()
}
fn default_instance() -> &'static CheckTxnStatusResponse {
static mut instance: ::protobuf::lazy::Lazy<CheckTxnStatusResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CheckTxnStatusResponse,
};
unsafe {
instance.get(CheckTxnStatusResponse::new)
}
}
}
impl ::protobuf::Clear for CheckTxnStatusResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.lock_ttl = 0;
self.commit_version = 0;
self.action = Action::NoAction;
self.lock_info.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for CheckTxnStatusResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
::protobuf::PbPrint::fmt(&self.lock_ttl, "lock_ttl", buf);
::protobuf::PbPrint::fmt(&self.commit_version, "commit_version", buf);
::protobuf::PbPrint::fmt(&self.action, "action", buf);
::protobuf::PbPrint::fmt(&self.lock_info, "lock_info", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for CheckTxnStatusResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
::protobuf::PbPrint::fmt(&self.lock_ttl, "lock_ttl", &mut s);
::protobuf::PbPrint::fmt(&self.commit_version, "commit_version", &mut s);
::protobuf::PbPrint::fmt(&self.action, "action", &mut s);
::protobuf::PbPrint::fmt(&self.lock_info, "lock_info", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for CheckTxnStatusResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CheckSecondaryLocksRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub keys: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
pub start_version: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CheckSecondaryLocksRequest {
fn default() -> &'a CheckSecondaryLocksRequest {
<CheckSecondaryLocksRequest as ::protobuf::Message>::default_instance()
}
}
impl CheckSecondaryLocksRequest {
pub fn new() -> CheckSecondaryLocksRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_keys(&self) -> &[::std::vec::Vec<u8>] {
&self.keys
}
pub fn clear_keys(&mut self) {
self.keys.clear();
}
pub fn set_keys(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
self.keys = v;
}
pub fn mut_keys(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
&mut self.keys
}
pub fn take_keys(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
::std::mem::replace(&mut self.keys, ::protobuf::RepeatedField::new())
}
pub fn get_start_version(&self) -> u64 {
self.start_version
}
pub fn clear_start_version(&mut self) {
self.start_version = 0;
}
pub fn set_start_version(&mut self, v: u64) {
self.start_version = v;
}
}
impl ::protobuf::Message for CheckSecondaryLocksRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.keys)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_version = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.keys {
my_size += ::protobuf::rt::bytes_size(2, &value);
};
if self.start_version != 0 {
my_size += ::protobuf::rt::value_size(3, self.start_version, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.keys {
os.write_bytes(2, &v)?;
};
if self.start_version != 0 {
os.write_uint64(3, self.start_version)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CheckSecondaryLocksRequest {
CheckSecondaryLocksRequest::new()
}
fn default_instance() -> &'static CheckSecondaryLocksRequest {
static mut instance: ::protobuf::lazy::Lazy<CheckSecondaryLocksRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CheckSecondaryLocksRequest,
};
unsafe {
instance.get(CheckSecondaryLocksRequest::new)
}
}
}
impl ::protobuf::Clear for CheckSecondaryLocksRequest {
fn clear(&mut self) {
self.context.clear();
self.keys.clear();
self.start_version = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for CheckSecondaryLocksRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.keys, "keys", buf);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for CheckSecondaryLocksRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.keys, "keys", &mut s);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for CheckSecondaryLocksRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CheckSecondaryLocksResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::protobuf::SingularPtrField<KeyError>,
pub locks: ::protobuf::RepeatedField<LockInfo>,
pub commit_ts: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CheckSecondaryLocksResponse {
fn default() -> &'a CheckSecondaryLocksResponse {
<CheckSecondaryLocksResponse as ::protobuf::Message>::default_instance()
}
}
impl CheckSecondaryLocksResponse {
pub fn new() -> CheckSecondaryLocksResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &KeyError {
self.error.as_ref().unwrap_or_else(|| KeyError::default_instance())
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn has_error(&self) -> bool {
self.error.is_some()
}
pub fn set_error(&mut self, v: KeyError) {
self.error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_error(&mut self) -> &mut KeyError {
if self.error.is_none() {
self.error.set_default();
}
self.error.as_mut().unwrap()
}
pub fn take_error(&mut self) -> KeyError {
self.error.take().unwrap_or_else(|| KeyError::new())
}
pub fn get_locks(&self) -> &[LockInfo] {
&self.locks
}
pub fn clear_locks(&mut self) {
self.locks.clear();
}
pub fn set_locks(&mut self, v: ::protobuf::RepeatedField<LockInfo>) {
self.locks = v;
}
pub fn mut_locks(&mut self) -> &mut ::protobuf::RepeatedField<LockInfo> {
&mut self.locks
}
pub fn take_locks(&mut self) -> ::protobuf::RepeatedField<LockInfo> {
::std::mem::replace(&mut self.locks, ::protobuf::RepeatedField::new())
}
pub fn get_commit_ts(&self) -> u64 {
self.commit_ts
}
pub fn clear_commit_ts(&mut self) {
self.commit_ts = 0;
}
pub fn set_commit_ts(&mut self, v: u64) {
self.commit_ts = v;
}
}
impl ::protobuf::Message for CheckSecondaryLocksResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.error {
if !v.is_initialized() {
return false;
}
};
for v in &self.locks {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.error)?;
},
3 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.locks)?;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.commit_ts = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.locks {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if self.commit_ts != 0 {
my_size += ::protobuf::rt::value_size(4, self.commit_ts, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.error.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.locks {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
if self.commit_ts != 0 {
os.write_uint64(4, self.commit_ts)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CheckSecondaryLocksResponse {
CheckSecondaryLocksResponse::new()
}
fn default_instance() -> &'static CheckSecondaryLocksResponse {
static mut instance: ::protobuf::lazy::Lazy<CheckSecondaryLocksResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CheckSecondaryLocksResponse,
};
unsafe {
instance.get(CheckSecondaryLocksResponse::new)
}
}
}
impl ::protobuf::Clear for CheckSecondaryLocksResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.locks.clear();
self.commit_ts = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for CheckSecondaryLocksResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
::protobuf::PbPrint::fmt(&self.locks, "locks", buf);
::protobuf::PbPrint::fmt(&self.commit_ts, "commit_ts", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for CheckSecondaryLocksResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
::protobuf::PbPrint::fmt(&self.locks, "locks", &mut s);
::protobuf::PbPrint::fmt(&self.commit_ts, "commit_ts", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for CheckSecondaryLocksResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CommitRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub start_version: u64,
pub keys: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
pub commit_version: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CommitRequest {
fn default() -> &'a CommitRequest {
<CommitRequest as ::protobuf::Message>::default_instance()
}
}
impl CommitRequest {
pub fn new() -> CommitRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_start_version(&self) -> u64 {
self.start_version
}
pub fn clear_start_version(&mut self) {
self.start_version = 0;
}
pub fn set_start_version(&mut self, v: u64) {
self.start_version = v;
}
pub fn get_keys(&self) -> &[::std::vec::Vec<u8>] {
&self.keys
}
pub fn clear_keys(&mut self) {
self.keys.clear();
}
pub fn set_keys(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
self.keys = v;
}
pub fn mut_keys(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
&mut self.keys
}
pub fn take_keys(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
::std::mem::replace(&mut self.keys, ::protobuf::RepeatedField::new())
}
pub fn get_commit_version(&self) -> u64 {
self.commit_version
}
pub fn clear_commit_version(&mut self) {
self.commit_version = 0;
}
pub fn set_commit_version(&mut self, v: u64) {
self.commit_version = v;
}
}
impl ::protobuf::Message for CommitRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_version = tmp;
},
3 => {
::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.keys)?;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.commit_version = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.start_version != 0 {
my_size += ::protobuf::rt::value_size(2, self.start_version, ::protobuf::wire_format::WireTypeVarint);
}
for value in &self.keys {
my_size += ::protobuf::rt::bytes_size(3, &value);
};
if self.commit_version != 0 {
my_size += ::protobuf::rt::value_size(4, self.commit_version, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.start_version != 0 {
os.write_uint64(2, self.start_version)?;
}
for v in &self.keys {
os.write_bytes(3, &v)?;
};
if self.commit_version != 0 {
os.write_uint64(4, self.commit_version)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CommitRequest {
CommitRequest::new()
}
fn default_instance() -> &'static CommitRequest {
static mut instance: ::protobuf::lazy::Lazy<CommitRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CommitRequest,
};
unsafe {
instance.get(CommitRequest::new)
}
}
}
impl ::protobuf::Clear for CommitRequest {
fn clear(&mut self) {
self.context.clear();
self.start_version = 0;
self.keys.clear();
self.commit_version = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for CommitRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", buf);
::protobuf::PbPrint::fmt(&self.keys, "keys", buf);
::protobuf::PbPrint::fmt(&self.commit_version, "commit_version", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for CommitRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", &mut s);
::protobuf::PbPrint::fmt(&self.keys, "keys", &mut s);
::protobuf::PbPrint::fmt(&self.commit_version, "commit_version", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for CommitRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CommitResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::protobuf::SingularPtrField<KeyError>,
pub commit_version: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CommitResponse {
fn default() -> &'a CommitResponse {
<CommitResponse as ::protobuf::Message>::default_instance()
}
}
impl CommitResponse {
pub fn new() -> CommitResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &KeyError {
self.error.as_ref().unwrap_or_else(|| KeyError::default_instance())
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn has_error(&self) -> bool {
self.error.is_some()
}
pub fn set_error(&mut self, v: KeyError) {
self.error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_error(&mut self) -> &mut KeyError {
if self.error.is_none() {
self.error.set_default();
}
self.error.as_mut().unwrap()
}
pub fn take_error(&mut self) -> KeyError {
self.error.take().unwrap_or_else(|| KeyError::new())
}
pub fn get_commit_version(&self) -> u64 {
self.commit_version
}
pub fn clear_commit_version(&mut self) {
self.commit_version = 0;
}
pub fn set_commit_version(&mut self, v: u64) {
self.commit_version = v;
}
}
impl ::protobuf::Message for CommitResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.error)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.commit_version = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.commit_version != 0 {
my_size += ::protobuf::rt::value_size(3, self.commit_version, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.error.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.commit_version != 0 {
os.write_uint64(3, self.commit_version)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CommitResponse {
CommitResponse::new()
}
fn default_instance() -> &'static CommitResponse {
static mut instance: ::protobuf::lazy::Lazy<CommitResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CommitResponse,
};
unsafe {
instance.get(CommitResponse::new)
}
}
}
impl ::protobuf::Clear for CommitResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.commit_version = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for CommitResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
::protobuf::PbPrint::fmt(&self.commit_version, "commit_version", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for CommitResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
::protobuf::PbPrint::fmt(&self.commit_version, "commit_version", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for CommitResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ImportRequest {
pub mutations: ::protobuf::RepeatedField<Mutation>,
pub commit_version: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ImportRequest {
fn default() -> &'a ImportRequest {
<ImportRequest as ::protobuf::Message>::default_instance()
}
}
impl ImportRequest {
pub fn new() -> ImportRequest {
::std::default::Default::default()
}
pub fn get_mutations(&self) -> &[Mutation] {
&self.mutations
}
pub fn clear_mutations(&mut self) {
self.mutations.clear();
}
pub fn set_mutations(&mut self, v: ::protobuf::RepeatedField<Mutation>) {
self.mutations = v;
}
pub fn mut_mutations(&mut self) -> &mut ::protobuf::RepeatedField<Mutation> {
&mut self.mutations
}
pub fn take_mutations(&mut self) -> ::protobuf::RepeatedField<Mutation> {
::std::mem::replace(&mut self.mutations, ::protobuf::RepeatedField::new())
}
pub fn get_commit_version(&self) -> u64 {
self.commit_version
}
pub fn clear_commit_version(&mut self) {
self.commit_version = 0;
}
pub fn set_commit_version(&mut self, v: u64) {
self.commit_version = v;
}
}
impl ::protobuf::Message for ImportRequest {
fn is_initialized(&self) -> bool {
for v in &self.mutations {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.mutations)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.commit_version = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
for value in &self.mutations {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if self.commit_version != 0 {
my_size += ::protobuf::rt::value_size(2, self.commit_version, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
for v in &self.mutations {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
if self.commit_version != 0 {
os.write_uint64(2, self.commit_version)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ImportRequest {
ImportRequest::new()
}
fn default_instance() -> &'static ImportRequest {
static mut instance: ::protobuf::lazy::Lazy<ImportRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ImportRequest,
};
unsafe {
instance.get(ImportRequest::new)
}
}
}
impl ::protobuf::Clear for ImportRequest {
fn clear(&mut self) {
self.mutations.clear();
self.commit_version = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for ImportRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.mutations, "mutations", buf);
::protobuf::PbPrint::fmt(&self.commit_version, "commit_version", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for ImportRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.mutations, "mutations", &mut s);
::protobuf::PbPrint::fmt(&self.commit_version, "commit_version", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for ImportRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ImportResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ImportResponse {
fn default() -> &'a ImportResponse {
<ImportResponse as ::protobuf::Message>::default_instance()
}
}
impl ImportResponse {
pub fn new() -> ImportResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &str {
&self.error
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn set_error(&mut self, v: ::std::string::String) {
self.error = v;
}
pub fn mut_error(&mut self) -> &mut ::std::string::String {
&mut self.error
}
pub fn take_error(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error, ::std::string::String::new())
}
}
impl ::protobuf::Message for ImportResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.error.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.error);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.error.is_empty() {
os.write_string(2, &self.error)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ImportResponse {
ImportResponse::new()
}
fn default_instance() -> &'static ImportResponse {
static mut instance: ::protobuf::lazy::Lazy<ImportResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ImportResponse,
};
unsafe {
instance.get(ImportResponse::new)
}
}
}
impl ::protobuf::Clear for ImportResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for ImportResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for ImportResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for ImportResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CleanupRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub key: ::std::vec::Vec<u8>,
pub start_version: u64,
pub current_ts: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CleanupRequest {
fn default() -> &'a CleanupRequest {
<CleanupRequest as ::protobuf::Message>::default_instance()
}
}
impl CleanupRequest {
pub fn new() -> CleanupRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_key(&self) -> &[u8] {
&self.key
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
self.key = v;
}
pub fn mut_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.key
}
pub fn take_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.key, ::std::vec::Vec::new())
}
pub fn get_start_version(&self) -> u64 {
self.start_version
}
pub fn clear_start_version(&mut self) {
self.start_version = 0;
}
pub fn set_start_version(&mut self, v: u64) {
self.start_version = v;
}
pub fn get_current_ts(&self) -> u64 {
self.current_ts
}
pub fn clear_current_ts(&mut self) {
self.current_ts = 0;
}
pub fn set_current_ts(&mut self, v: u64) {
self.current_ts = v;
}
}
impl ::protobuf::Message for CleanupRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_version = tmp;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.current_ts = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.key);
}
if self.start_version != 0 {
my_size += ::protobuf::rt::value_size(3, self.start_version, ::protobuf::wire_format::WireTypeVarint);
}
if self.current_ts != 0 {
my_size += ::protobuf::rt::value_size(4, self.current_ts, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.key.is_empty() {
os.write_bytes(2, &self.key)?;
}
if self.start_version != 0 {
os.write_uint64(3, self.start_version)?;
}
if self.current_ts != 0 {
os.write_uint64(4, self.current_ts)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CleanupRequest {
CleanupRequest::new()
}
fn default_instance() -> &'static CleanupRequest {
static mut instance: ::protobuf::lazy::Lazy<CleanupRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CleanupRequest,
};
unsafe {
instance.get(CleanupRequest::new)
}
}
}
impl ::protobuf::Clear for CleanupRequest {
fn clear(&mut self) {
self.context.clear();
self.key.clear();
self.start_version = 0;
self.current_ts = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for CleanupRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.key, "key", buf);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", buf);
::protobuf::PbPrint::fmt(&self.current_ts, "current_ts", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for CleanupRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.key, "key", &mut s);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", &mut s);
::protobuf::PbPrint::fmt(&self.current_ts, "current_ts", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for CleanupRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CleanupResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::protobuf::SingularPtrField<KeyError>,
pub commit_version: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CleanupResponse {
fn default() -> &'a CleanupResponse {
<CleanupResponse as ::protobuf::Message>::default_instance()
}
}
impl CleanupResponse {
pub fn new() -> CleanupResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &KeyError {
self.error.as_ref().unwrap_or_else(|| KeyError::default_instance())
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn has_error(&self) -> bool {
self.error.is_some()
}
pub fn set_error(&mut self, v: KeyError) {
self.error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_error(&mut self) -> &mut KeyError {
if self.error.is_none() {
self.error.set_default();
}
self.error.as_mut().unwrap()
}
pub fn take_error(&mut self) -> KeyError {
self.error.take().unwrap_or_else(|| KeyError::new())
}
pub fn get_commit_version(&self) -> u64 {
self.commit_version
}
pub fn clear_commit_version(&mut self) {
self.commit_version = 0;
}
pub fn set_commit_version(&mut self, v: u64) {
self.commit_version = v;
}
}
impl ::protobuf::Message for CleanupResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.error)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.commit_version = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.commit_version != 0 {
my_size += ::protobuf::rt::value_size(3, self.commit_version, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.error.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.commit_version != 0 {
os.write_uint64(3, self.commit_version)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CleanupResponse {
CleanupResponse::new()
}
fn default_instance() -> &'static CleanupResponse {
static mut instance: ::protobuf::lazy::Lazy<CleanupResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CleanupResponse,
};
unsafe {
instance.get(CleanupResponse::new)
}
}
}
impl ::protobuf::Clear for CleanupResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.commit_version = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for CleanupResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
::protobuf::PbPrint::fmt(&self.commit_version, "commit_version", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for CleanupResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
::protobuf::PbPrint::fmt(&self.commit_version, "commit_version", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for CleanupResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct BatchGetRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub keys: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
pub version: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a BatchGetRequest {
fn default() -> &'a BatchGetRequest {
<BatchGetRequest as ::protobuf::Message>::default_instance()
}
}
impl BatchGetRequest {
pub fn new() -> BatchGetRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_keys(&self) -> &[::std::vec::Vec<u8>] {
&self.keys
}
pub fn clear_keys(&mut self) {
self.keys.clear();
}
pub fn set_keys(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
self.keys = v;
}
pub fn mut_keys(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
&mut self.keys
}
pub fn take_keys(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
::std::mem::replace(&mut self.keys, ::protobuf::RepeatedField::new())
}
pub fn get_version(&self) -> u64 {
self.version
}
pub fn clear_version(&mut self) {
self.version = 0;
}
pub fn set_version(&mut self, v: u64) {
self.version = v;
}
}
impl ::protobuf::Message for BatchGetRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.keys)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.version = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.keys {
my_size += ::protobuf::rt::bytes_size(2, &value);
};
if self.version != 0 {
my_size += ::protobuf::rt::value_size(3, self.version, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.keys {
os.write_bytes(2, &v)?;
};
if self.version != 0 {
os.write_uint64(3, self.version)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> BatchGetRequest {
BatchGetRequest::new()
}
fn default_instance() -> &'static BatchGetRequest {
static mut instance: ::protobuf::lazy::Lazy<BatchGetRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const BatchGetRequest,
};
unsafe {
instance.get(BatchGetRequest::new)
}
}
}
impl ::protobuf::Clear for BatchGetRequest {
fn clear(&mut self) {
self.context.clear();
self.keys.clear();
self.version = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for BatchGetRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.keys, "keys", buf);
::protobuf::PbPrint::fmt(&self.version, "version", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for BatchGetRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.keys, "keys", &mut s);
::protobuf::PbPrint::fmt(&self.version, "version", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for BatchGetRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct BatchGetResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub pairs: ::protobuf::RepeatedField<KvPair>,
pub exec_details_v2: ::protobuf::SingularPtrField<ExecDetailsV2>,
pub error: ::protobuf::SingularPtrField<KeyError>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a BatchGetResponse {
fn default() -> &'a BatchGetResponse {
<BatchGetResponse as ::protobuf::Message>::default_instance()
}
}
impl BatchGetResponse {
pub fn new() -> BatchGetResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_pairs(&self) -> &[KvPair] {
&self.pairs
}
pub fn clear_pairs(&mut self) {
self.pairs.clear();
}
pub fn set_pairs(&mut self, v: ::protobuf::RepeatedField<KvPair>) {
self.pairs = v;
}
pub fn mut_pairs(&mut self) -> &mut ::protobuf::RepeatedField<KvPair> {
&mut self.pairs
}
pub fn take_pairs(&mut self) -> ::protobuf::RepeatedField<KvPair> {
::std::mem::replace(&mut self.pairs, ::protobuf::RepeatedField::new())
}
pub fn get_exec_details_v2(&self) -> &ExecDetailsV2 {
self.exec_details_v2.as_ref().unwrap_or_else(|| ExecDetailsV2::default_instance())
}
pub fn clear_exec_details_v2(&mut self) {
self.exec_details_v2.clear();
}
pub fn has_exec_details_v2(&self) -> bool {
self.exec_details_v2.is_some()
}
pub fn set_exec_details_v2(&mut self, v: ExecDetailsV2) {
self.exec_details_v2 = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_exec_details_v2(&mut self) -> &mut ExecDetailsV2 {
if self.exec_details_v2.is_none() {
self.exec_details_v2.set_default();
}
self.exec_details_v2.as_mut().unwrap()
}
pub fn take_exec_details_v2(&mut self) -> ExecDetailsV2 {
self.exec_details_v2.take().unwrap_or_else(|| ExecDetailsV2::new())
}
pub fn get_error(&self) -> &KeyError {
self.error.as_ref().unwrap_or_else(|| KeyError::default_instance())
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn has_error(&self) -> bool {
self.error.is_some()
}
pub fn set_error(&mut self, v: KeyError) {
self.error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_error(&mut self) -> &mut KeyError {
if self.error.is_none() {
self.error.set_default();
}
self.error.as_mut().unwrap()
}
pub fn take_error(&mut self) -> KeyError {
self.error.take().unwrap_or_else(|| KeyError::new())
}
}
impl ::protobuf::Message for BatchGetResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.pairs {
if !v.is_initialized() {
return false;
}
};
for v in &self.exec_details_v2 {
if !v.is_initialized() {
return false;
}
};
for v in &self.error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.pairs)?;
},
4 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.exec_details_v2)?;
},
5 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.pairs {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if let Some(ref v) = self.exec_details_v2.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.pairs {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
if let Some(ref v) = self.exec_details_v2.as_ref() {
os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.error.as_ref() {
os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> BatchGetResponse {
BatchGetResponse::new()
}
fn default_instance() -> &'static BatchGetResponse {
static mut instance: ::protobuf::lazy::Lazy<BatchGetResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const BatchGetResponse,
};
unsafe {
instance.get(BatchGetResponse::new)
}
}
}
impl ::protobuf::Clear for BatchGetResponse {
fn clear(&mut self) {
self.region_error.clear();
self.pairs.clear();
self.exec_details_v2.clear();
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for BatchGetResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.pairs, "pairs", buf);
::protobuf::PbPrint::fmt(&self.exec_details_v2, "exec_details_v2", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for BatchGetResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.pairs, "pairs", &mut s);
::protobuf::PbPrint::fmt(&self.exec_details_v2, "exec_details_v2", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for BatchGetResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct BatchRollbackRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub start_version: u64,
pub keys: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a BatchRollbackRequest {
fn default() -> &'a BatchRollbackRequest {
<BatchRollbackRequest as ::protobuf::Message>::default_instance()
}
}
impl BatchRollbackRequest {
pub fn new() -> BatchRollbackRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_start_version(&self) -> u64 {
self.start_version
}
pub fn clear_start_version(&mut self) {
self.start_version = 0;
}
pub fn set_start_version(&mut self, v: u64) {
self.start_version = v;
}
pub fn get_keys(&self) -> &[::std::vec::Vec<u8>] {
&self.keys
}
pub fn clear_keys(&mut self) {
self.keys.clear();
}
pub fn set_keys(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
self.keys = v;
}
pub fn mut_keys(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
&mut self.keys
}
pub fn take_keys(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
::std::mem::replace(&mut self.keys, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for BatchRollbackRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_version = tmp;
},
3 => {
::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.keys)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.start_version != 0 {
my_size += ::protobuf::rt::value_size(2, self.start_version, ::protobuf::wire_format::WireTypeVarint);
}
for value in &self.keys {
my_size += ::protobuf::rt::bytes_size(3, &value);
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.start_version != 0 {
os.write_uint64(2, self.start_version)?;
}
for v in &self.keys {
os.write_bytes(3, &v)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> BatchRollbackRequest {
BatchRollbackRequest::new()
}
fn default_instance() -> &'static BatchRollbackRequest {
static mut instance: ::protobuf::lazy::Lazy<BatchRollbackRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const BatchRollbackRequest,
};
unsafe {
instance.get(BatchRollbackRequest::new)
}
}
}
impl ::protobuf::Clear for BatchRollbackRequest {
fn clear(&mut self) {
self.context.clear();
self.start_version = 0;
self.keys.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for BatchRollbackRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", buf);
::protobuf::PbPrint::fmt(&self.keys, "keys", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for BatchRollbackRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", &mut s);
::protobuf::PbPrint::fmt(&self.keys, "keys", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for BatchRollbackRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct BatchRollbackResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::protobuf::SingularPtrField<KeyError>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a BatchRollbackResponse {
fn default() -> &'a BatchRollbackResponse {
<BatchRollbackResponse as ::protobuf::Message>::default_instance()
}
}
impl BatchRollbackResponse {
pub fn new() -> BatchRollbackResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &KeyError {
self.error.as_ref().unwrap_or_else(|| KeyError::default_instance())
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn has_error(&self) -> bool {
self.error.is_some()
}
pub fn set_error(&mut self, v: KeyError) {
self.error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_error(&mut self) -> &mut KeyError {
if self.error.is_none() {
self.error.set_default();
}
self.error.as_mut().unwrap()
}
pub fn take_error(&mut self) -> KeyError {
self.error.take().unwrap_or_else(|| KeyError::new())
}
}
impl ::protobuf::Message for BatchRollbackResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.error.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> BatchRollbackResponse {
BatchRollbackResponse::new()
}
fn default_instance() -> &'static BatchRollbackResponse {
static mut instance: ::protobuf::lazy::Lazy<BatchRollbackResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const BatchRollbackResponse,
};
unsafe {
instance.get(BatchRollbackResponse::new)
}
}
}
impl ::protobuf::Clear for BatchRollbackResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for BatchRollbackResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for BatchRollbackResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for BatchRollbackResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ScanLockRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub max_version: u64,
pub start_key: ::std::vec::Vec<u8>,
pub limit: u32,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ScanLockRequest {
fn default() -> &'a ScanLockRequest {
<ScanLockRequest as ::protobuf::Message>::default_instance()
}
}
impl ScanLockRequest {
pub fn new() -> ScanLockRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_max_version(&self) -> u64 {
self.max_version
}
pub fn clear_max_version(&mut self) {
self.max_version = 0;
}
pub fn set_max_version(&mut self, v: u64) {
self.max_version = v;
}
pub fn get_start_key(&self) -> &[u8] {
&self.start_key
}
pub fn clear_start_key(&mut self) {
self.start_key.clear();
}
pub fn set_start_key(&mut self, v: ::std::vec::Vec<u8>) {
self.start_key = v;
}
pub fn mut_start_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.start_key
}
pub fn take_start_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.start_key, ::std::vec::Vec::new())
}
pub fn get_limit(&self) -> u32 {
self.limit
}
pub fn clear_limit(&mut self) {
self.limit = 0;
}
pub fn set_limit(&mut self, v: u32) {
self.limit = v;
}
}
impl ::protobuf::Message for ScanLockRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.max_version = tmp;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.start_key)?;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.limit = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.max_version != 0 {
my_size += ::protobuf::rt::value_size(2, self.max_version, ::protobuf::wire_format::WireTypeVarint);
}
if !self.start_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.start_key);
}
if self.limit != 0 {
my_size += ::protobuf::rt::value_size(4, self.limit, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.max_version != 0 {
os.write_uint64(2, self.max_version)?;
}
if !self.start_key.is_empty() {
os.write_bytes(3, &self.start_key)?;
}
if self.limit != 0 {
os.write_uint32(4, self.limit)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ScanLockRequest {
ScanLockRequest::new()
}
fn default_instance() -> &'static ScanLockRequest {
static mut instance: ::protobuf::lazy::Lazy<ScanLockRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ScanLockRequest,
};
unsafe {
instance.get(ScanLockRequest::new)
}
}
}
impl ::protobuf::Clear for ScanLockRequest {
fn clear(&mut self) {
self.context.clear();
self.max_version = 0;
self.start_key.clear();
self.limit = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for ScanLockRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.max_version, "max_version", buf);
::protobuf::PbPrint::fmt(&self.start_key, "start_key", buf);
::protobuf::PbPrint::fmt(&self.limit, "limit", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for ScanLockRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.max_version, "max_version", &mut s);
::protobuf::PbPrint::fmt(&self.start_key, "start_key", &mut s);
::protobuf::PbPrint::fmt(&self.limit, "limit", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for ScanLockRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ScanLockResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::protobuf::SingularPtrField<KeyError>,
pub locks: ::protobuf::RepeatedField<LockInfo>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ScanLockResponse {
fn default() -> &'a ScanLockResponse {
<ScanLockResponse as ::protobuf::Message>::default_instance()
}
}
impl ScanLockResponse {
pub fn new() -> ScanLockResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &KeyError {
self.error.as_ref().unwrap_or_else(|| KeyError::default_instance())
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn has_error(&self) -> bool {
self.error.is_some()
}
pub fn set_error(&mut self, v: KeyError) {
self.error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_error(&mut self) -> &mut KeyError {
if self.error.is_none() {
self.error.set_default();
}
self.error.as_mut().unwrap()
}
pub fn take_error(&mut self) -> KeyError {
self.error.take().unwrap_or_else(|| KeyError::new())
}
pub fn get_locks(&self) -> &[LockInfo] {
&self.locks
}
pub fn clear_locks(&mut self) {
self.locks.clear();
}
pub fn set_locks(&mut self, v: ::protobuf::RepeatedField<LockInfo>) {
self.locks = v;
}
pub fn mut_locks(&mut self) -> &mut ::protobuf::RepeatedField<LockInfo> {
&mut self.locks
}
pub fn take_locks(&mut self) -> ::protobuf::RepeatedField<LockInfo> {
::std::mem::replace(&mut self.locks, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for ScanLockResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.error {
if !v.is_initialized() {
return false;
}
};
for v in &self.locks {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.error)?;
},
3 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.locks)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.locks {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.error.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.locks {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ScanLockResponse {
ScanLockResponse::new()
}
fn default_instance() -> &'static ScanLockResponse {
static mut instance: ::protobuf::lazy::Lazy<ScanLockResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ScanLockResponse,
};
unsafe {
instance.get(ScanLockResponse::new)
}
}
}
impl ::protobuf::Clear for ScanLockResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.locks.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for ScanLockResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
::protobuf::PbPrint::fmt(&self.locks, "locks", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for ScanLockResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
::protobuf::PbPrint::fmt(&self.locks, "locks", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for ScanLockResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ResolveLockRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub start_version: u64,
pub commit_version: u64,
pub txn_infos: ::protobuf::RepeatedField<TxnInfo>,
pub keys: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ResolveLockRequest {
fn default() -> &'a ResolveLockRequest {
<ResolveLockRequest as ::protobuf::Message>::default_instance()
}
}
impl ResolveLockRequest {
pub fn new() -> ResolveLockRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_start_version(&self) -> u64 {
self.start_version
}
pub fn clear_start_version(&mut self) {
self.start_version = 0;
}
pub fn set_start_version(&mut self, v: u64) {
self.start_version = v;
}
pub fn get_commit_version(&self) -> u64 {
self.commit_version
}
pub fn clear_commit_version(&mut self) {
self.commit_version = 0;
}
pub fn set_commit_version(&mut self, v: u64) {
self.commit_version = v;
}
pub fn get_txn_infos(&self) -> &[TxnInfo] {
&self.txn_infos
}
pub fn clear_txn_infos(&mut self) {
self.txn_infos.clear();
}
pub fn set_txn_infos(&mut self, v: ::protobuf::RepeatedField<TxnInfo>) {
self.txn_infos = v;
}
pub fn mut_txn_infos(&mut self) -> &mut ::protobuf::RepeatedField<TxnInfo> {
&mut self.txn_infos
}
pub fn take_txn_infos(&mut self) -> ::protobuf::RepeatedField<TxnInfo> {
::std::mem::replace(&mut self.txn_infos, ::protobuf::RepeatedField::new())
}
pub fn get_keys(&self) -> &[::std::vec::Vec<u8>] {
&self.keys
}
pub fn clear_keys(&mut self) {
self.keys.clear();
}
pub fn set_keys(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
self.keys = v;
}
pub fn mut_keys(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
&mut self.keys
}
pub fn take_keys(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
::std::mem::replace(&mut self.keys, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for ResolveLockRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
for v in &self.txn_infos {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_version = tmp;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.commit_version = tmp;
},
4 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.txn_infos)?;
},
5 => {
::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.keys)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.start_version != 0 {
my_size += ::protobuf::rt::value_size(2, self.start_version, ::protobuf::wire_format::WireTypeVarint);
}
if self.commit_version != 0 {
my_size += ::protobuf::rt::value_size(3, self.commit_version, ::protobuf::wire_format::WireTypeVarint);
}
for value in &self.txn_infos {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
for value in &self.keys {
my_size += ::protobuf::rt::bytes_size(5, &value);
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.start_version != 0 {
os.write_uint64(2, self.start_version)?;
}
if self.commit_version != 0 {
os.write_uint64(3, self.commit_version)?;
}
for v in &self.txn_infos {
os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
for v in &self.keys {
os.write_bytes(5, &v)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ResolveLockRequest {
ResolveLockRequest::new()
}
fn default_instance() -> &'static ResolveLockRequest {
static mut instance: ::protobuf::lazy::Lazy<ResolveLockRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ResolveLockRequest,
};
unsafe {
instance.get(ResolveLockRequest::new)
}
}
}
impl ::protobuf::Clear for ResolveLockRequest {
fn clear(&mut self) {
self.context.clear();
self.start_version = 0;
self.commit_version = 0;
self.txn_infos.clear();
self.keys.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for ResolveLockRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", buf);
::protobuf::PbPrint::fmt(&self.commit_version, "commit_version", buf);
::protobuf::PbPrint::fmt(&self.txn_infos, "txn_infos", buf);
::protobuf::PbPrint::fmt(&self.keys, "keys", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for ResolveLockRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", &mut s);
::protobuf::PbPrint::fmt(&self.commit_version, "commit_version", &mut s);
::protobuf::PbPrint::fmt(&self.txn_infos, "txn_infos", &mut s);
::protobuf::PbPrint::fmt(&self.keys, "keys", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for ResolveLockRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ResolveLockResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::protobuf::SingularPtrField<KeyError>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ResolveLockResponse {
fn default() -> &'a ResolveLockResponse {
<ResolveLockResponse as ::protobuf::Message>::default_instance()
}
}
impl ResolveLockResponse {
pub fn new() -> ResolveLockResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &KeyError {
self.error.as_ref().unwrap_or_else(|| KeyError::default_instance())
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn has_error(&self) -> bool {
self.error.is_some()
}
pub fn set_error(&mut self, v: KeyError) {
self.error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_error(&mut self) -> &mut KeyError {
if self.error.is_none() {
self.error.set_default();
}
self.error.as_mut().unwrap()
}
pub fn take_error(&mut self) -> KeyError {
self.error.take().unwrap_or_else(|| KeyError::new())
}
}
impl ::protobuf::Message for ResolveLockResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.error.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ResolveLockResponse {
ResolveLockResponse::new()
}
fn default_instance() -> &'static ResolveLockResponse {
static mut instance: ::protobuf::lazy::Lazy<ResolveLockResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ResolveLockResponse,
};
unsafe {
instance.get(ResolveLockResponse::new)
}
}
}
impl ::protobuf::Clear for ResolveLockResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for ResolveLockResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for ResolveLockResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for ResolveLockResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct GcRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub safe_point: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a GcRequest {
fn default() -> &'a GcRequest {
<GcRequest as ::protobuf::Message>::default_instance()
}
}
impl GcRequest {
pub fn new() -> GcRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_safe_point(&self) -> u64 {
self.safe_point
}
pub fn clear_safe_point(&mut self) {
self.safe_point = 0;
}
pub fn set_safe_point(&mut self, v: u64) {
self.safe_point = v;
}
}
impl ::protobuf::Message for GcRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.safe_point = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.safe_point != 0 {
my_size += ::protobuf::rt::value_size(2, self.safe_point, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.safe_point != 0 {
os.write_uint64(2, self.safe_point)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> GcRequest {
GcRequest::new()
}
fn default_instance() -> &'static GcRequest {
static mut instance: ::protobuf::lazy::Lazy<GcRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const GcRequest,
};
unsafe {
instance.get(GcRequest::new)
}
}
}
impl ::protobuf::Clear for GcRequest {
fn clear(&mut self) {
self.context.clear();
self.safe_point = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for GcRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.safe_point, "safe_point", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for GcRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.safe_point, "safe_point", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for GcRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct GcResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::protobuf::SingularPtrField<KeyError>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a GcResponse {
fn default() -> &'a GcResponse {
<GcResponse as ::protobuf::Message>::default_instance()
}
}
impl GcResponse {
pub fn new() -> GcResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &KeyError {
self.error.as_ref().unwrap_or_else(|| KeyError::default_instance())
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn has_error(&self) -> bool {
self.error.is_some()
}
pub fn set_error(&mut self, v: KeyError) {
self.error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_error(&mut self) -> &mut KeyError {
if self.error.is_none() {
self.error.set_default();
}
self.error.as_mut().unwrap()
}
pub fn take_error(&mut self) -> KeyError {
self.error.take().unwrap_or_else(|| KeyError::new())
}
}
impl ::protobuf::Message for GcResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.error.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> GcResponse {
GcResponse::new()
}
fn default_instance() -> &'static GcResponse {
static mut instance: ::protobuf::lazy::Lazy<GcResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const GcResponse,
};
unsafe {
instance.get(GcResponse::new)
}
}
}
impl ::protobuf::Clear for GcResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for GcResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for GcResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for GcResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct DeleteRangeRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub start_key: ::std::vec::Vec<u8>,
pub end_key: ::std::vec::Vec<u8>,
pub notify_only: bool,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a DeleteRangeRequest {
fn default() -> &'a DeleteRangeRequest {
<DeleteRangeRequest as ::protobuf::Message>::default_instance()
}
}
impl DeleteRangeRequest {
pub fn new() -> DeleteRangeRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_start_key(&self) -> &[u8] {
&self.start_key
}
pub fn clear_start_key(&mut self) {
self.start_key.clear();
}
pub fn set_start_key(&mut self, v: ::std::vec::Vec<u8>) {
self.start_key = v;
}
pub fn mut_start_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.start_key
}
pub fn take_start_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.start_key, ::std::vec::Vec::new())
}
pub fn get_end_key(&self) -> &[u8] {
&self.end_key
}
pub fn clear_end_key(&mut self) {
self.end_key.clear();
}
pub fn set_end_key(&mut self, v: ::std::vec::Vec<u8>) {
self.end_key = v;
}
pub fn mut_end_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.end_key
}
pub fn take_end_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.end_key, ::std::vec::Vec::new())
}
pub fn get_notify_only(&self) -> bool {
self.notify_only
}
pub fn clear_notify_only(&mut self) {
self.notify_only = false;
}
pub fn set_notify_only(&mut self, v: bool) {
self.notify_only = v;
}
}
impl ::protobuf::Message for DeleteRangeRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.start_key)?;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.end_key)?;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.notify_only = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.start_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.start_key);
}
if !self.end_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.end_key);
}
if self.notify_only != false {
my_size += 2;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.start_key.is_empty() {
os.write_bytes(2, &self.start_key)?;
}
if !self.end_key.is_empty() {
os.write_bytes(3, &self.end_key)?;
}
if self.notify_only != false {
os.write_bool(4, self.notify_only)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> DeleteRangeRequest {
DeleteRangeRequest::new()
}
fn default_instance() -> &'static DeleteRangeRequest {
static mut instance: ::protobuf::lazy::Lazy<DeleteRangeRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const DeleteRangeRequest,
};
unsafe {
instance.get(DeleteRangeRequest::new)
}
}
}
impl ::protobuf::Clear for DeleteRangeRequest {
fn clear(&mut self) {
self.context.clear();
self.start_key.clear();
self.end_key.clear();
self.notify_only = false;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for DeleteRangeRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.start_key, "start_key", buf);
::protobuf::PbPrint::fmt(&self.end_key, "end_key", buf);
::protobuf::PbPrint::fmt(&self.notify_only, "notify_only", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for DeleteRangeRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.start_key, "start_key", &mut s);
::protobuf::PbPrint::fmt(&self.end_key, "end_key", &mut s);
::protobuf::PbPrint::fmt(&self.notify_only, "notify_only", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for DeleteRangeRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct DeleteRangeResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a DeleteRangeResponse {
fn default() -> &'a DeleteRangeResponse {
<DeleteRangeResponse as ::protobuf::Message>::default_instance()
}
}
impl DeleteRangeResponse {
pub fn new() -> DeleteRangeResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &str {
&self.error
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn set_error(&mut self, v: ::std::string::String) {
self.error = v;
}
pub fn mut_error(&mut self) -> &mut ::std::string::String {
&mut self.error
}
pub fn take_error(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error, ::std::string::String::new())
}
}
impl ::protobuf::Message for DeleteRangeResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.error.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.error);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.error.is_empty() {
os.write_string(2, &self.error)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> DeleteRangeResponse {
DeleteRangeResponse::new()
}
fn default_instance() -> &'static DeleteRangeResponse {
static mut instance: ::protobuf::lazy::Lazy<DeleteRangeResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const DeleteRangeResponse,
};
unsafe {
instance.get(DeleteRangeResponse::new)
}
}
}
impl ::protobuf::Clear for DeleteRangeResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for DeleteRangeResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for DeleteRangeResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for DeleteRangeResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RawGetRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub key: ::std::vec::Vec<u8>,
pub cf: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RawGetRequest {
fn default() -> &'a RawGetRequest {
<RawGetRequest as ::protobuf::Message>::default_instance()
}
}
impl RawGetRequest {
pub fn new() -> RawGetRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_key(&self) -> &[u8] {
&self.key
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
self.key = v;
}
pub fn mut_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.key
}
pub fn take_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.key, ::std::vec::Vec::new())
}
pub fn get_cf(&self) -> &str {
&self.cf
}
pub fn clear_cf(&mut self) {
self.cf.clear();
}
pub fn set_cf(&mut self, v: ::std::string::String) {
self.cf = v;
}
pub fn mut_cf(&mut self) -> &mut ::std::string::String {
&mut self.cf
}
pub fn take_cf(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.cf, ::std::string::String::new())
}
}
impl ::protobuf::Message for RawGetRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?;
},
3 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.cf)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.key);
}
if !self.cf.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.cf);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.key.is_empty() {
os.write_bytes(2, &self.key)?;
}
if !self.cf.is_empty() {
os.write_string(3, &self.cf)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RawGetRequest {
RawGetRequest::new()
}
fn default_instance() -> &'static RawGetRequest {
static mut instance: ::protobuf::lazy::Lazy<RawGetRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RawGetRequest,
};
unsafe {
instance.get(RawGetRequest::new)
}
}
}
impl ::protobuf::Clear for RawGetRequest {
fn clear(&mut self) {
self.context.clear();
self.key.clear();
self.cf.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RawGetRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.key, "key", buf);
::protobuf::PbPrint::fmt(&self.cf, "cf", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RawGetRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.key, "key", &mut s);
::protobuf::PbPrint::fmt(&self.cf, "cf", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RawGetRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RawGetResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::std::string::String,
pub value: ::std::vec::Vec<u8>,
pub not_found: bool,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RawGetResponse {
fn default() -> &'a RawGetResponse {
<RawGetResponse as ::protobuf::Message>::default_instance()
}
}
impl RawGetResponse {
pub fn new() -> RawGetResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &str {
&self.error
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn set_error(&mut self, v: ::std::string::String) {
self.error = v;
}
pub fn mut_error(&mut self) -> &mut ::std::string::String {
&mut self.error
}
pub fn take_error(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error, ::std::string::String::new())
}
pub fn get_value(&self) -> &[u8] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::std::vec::Vec<u8>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.value
}
pub fn take_value(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.value, ::std::vec::Vec::new())
}
pub fn get_not_found(&self) -> bool {
self.not_found
}
pub fn clear_not_found(&mut self) {
self.not_found = false;
}
pub fn set_not_found(&mut self, v: bool) {
self.not_found = v;
}
}
impl ::protobuf::Message for RawGetResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.error)?;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.not_found = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.error.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.error);
}
if !self.value.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.value);
}
if self.not_found != false {
my_size += 2;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.error.is_empty() {
os.write_string(2, &self.error)?;
}
if !self.value.is_empty() {
os.write_bytes(3, &self.value)?;
}
if self.not_found != false {
os.write_bool(4, self.not_found)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RawGetResponse {
RawGetResponse::new()
}
fn default_instance() -> &'static RawGetResponse {
static mut instance: ::protobuf::lazy::Lazy<RawGetResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RawGetResponse,
};
unsafe {
instance.get(RawGetResponse::new)
}
}
}
impl ::protobuf::Clear for RawGetResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.value.clear();
self.not_found = false;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RawGetResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
::protobuf::PbPrint::fmt(&self.value, "value", buf);
::protobuf::PbPrint::fmt(&self.not_found, "not_found", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RawGetResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
::protobuf::PbPrint::fmt(&self.value, "value", &mut s);
::protobuf::PbPrint::fmt(&self.not_found, "not_found", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RawGetResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RawBatchGetRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub keys: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
pub cf: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RawBatchGetRequest {
fn default() -> &'a RawBatchGetRequest {
<RawBatchGetRequest as ::protobuf::Message>::default_instance()
}
}
impl RawBatchGetRequest {
pub fn new() -> RawBatchGetRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_keys(&self) -> &[::std::vec::Vec<u8>] {
&self.keys
}
pub fn clear_keys(&mut self) {
self.keys.clear();
}
pub fn set_keys(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
self.keys = v;
}
pub fn mut_keys(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
&mut self.keys
}
pub fn take_keys(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
::std::mem::replace(&mut self.keys, ::protobuf::RepeatedField::new())
}
pub fn get_cf(&self) -> &str {
&self.cf
}
pub fn clear_cf(&mut self) {
self.cf.clear();
}
pub fn set_cf(&mut self, v: ::std::string::String) {
self.cf = v;
}
pub fn mut_cf(&mut self) -> &mut ::std::string::String {
&mut self.cf
}
pub fn take_cf(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.cf, ::std::string::String::new())
}
}
impl ::protobuf::Message for RawBatchGetRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.keys)?;
},
3 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.cf)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.keys {
my_size += ::protobuf::rt::bytes_size(2, &value);
};
if !self.cf.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.cf);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.keys {
os.write_bytes(2, &v)?;
};
if !self.cf.is_empty() {
os.write_string(3, &self.cf)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RawBatchGetRequest {
RawBatchGetRequest::new()
}
fn default_instance() -> &'static RawBatchGetRequest {
static mut instance: ::protobuf::lazy::Lazy<RawBatchGetRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RawBatchGetRequest,
};
unsafe {
instance.get(RawBatchGetRequest::new)
}
}
}
impl ::protobuf::Clear for RawBatchGetRequest {
fn clear(&mut self) {
self.context.clear();
self.keys.clear();
self.cf.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RawBatchGetRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.keys, "keys", buf);
::protobuf::PbPrint::fmt(&self.cf, "cf", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RawBatchGetRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.keys, "keys", &mut s);
::protobuf::PbPrint::fmt(&self.cf, "cf", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RawBatchGetRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RawBatchGetResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub pairs: ::protobuf::RepeatedField<KvPair>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RawBatchGetResponse {
fn default() -> &'a RawBatchGetResponse {
<RawBatchGetResponse as ::protobuf::Message>::default_instance()
}
}
impl RawBatchGetResponse {
pub fn new() -> RawBatchGetResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_pairs(&self) -> &[KvPair] {
&self.pairs
}
pub fn clear_pairs(&mut self) {
self.pairs.clear();
}
pub fn set_pairs(&mut self, v: ::protobuf::RepeatedField<KvPair>) {
self.pairs = v;
}
pub fn mut_pairs(&mut self) -> &mut ::protobuf::RepeatedField<KvPair> {
&mut self.pairs
}
pub fn take_pairs(&mut self) -> ::protobuf::RepeatedField<KvPair> {
::std::mem::replace(&mut self.pairs, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for RawBatchGetResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.pairs {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.pairs)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.pairs {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.pairs {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RawBatchGetResponse {
RawBatchGetResponse::new()
}
fn default_instance() -> &'static RawBatchGetResponse {
static mut instance: ::protobuf::lazy::Lazy<RawBatchGetResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RawBatchGetResponse,
};
unsafe {
instance.get(RawBatchGetResponse::new)
}
}
}
impl ::protobuf::Clear for RawBatchGetResponse {
fn clear(&mut self) {
self.region_error.clear();
self.pairs.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RawBatchGetResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.pairs, "pairs", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RawBatchGetResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.pairs, "pairs", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RawBatchGetResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RawPutRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub key: ::std::vec::Vec<u8>,
pub value: ::std::vec::Vec<u8>,
pub cf: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RawPutRequest {
fn default() -> &'a RawPutRequest {
<RawPutRequest as ::protobuf::Message>::default_instance()
}
}
impl RawPutRequest {
pub fn new() -> RawPutRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_key(&self) -> &[u8] {
&self.key
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
self.key = v;
}
pub fn mut_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.key
}
pub fn take_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.key, ::std::vec::Vec::new())
}
pub fn get_value(&self) -> &[u8] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::std::vec::Vec<u8>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.value
}
pub fn take_value(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.value, ::std::vec::Vec::new())
}
pub fn get_cf(&self) -> &str {
&self.cf
}
pub fn clear_cf(&mut self) {
self.cf.clear();
}
pub fn set_cf(&mut self, v: ::std::string::String) {
self.cf = v;
}
pub fn mut_cf(&mut self) -> &mut ::std::string::String {
&mut self.cf
}
pub fn take_cf(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.cf, ::std::string::String::new())
}
}
impl ::protobuf::Message for RawPutRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
},
4 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.cf)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.key);
}
if !self.value.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.value);
}
if !self.cf.is_empty() {
my_size += ::protobuf::rt::string_size(4, &self.cf);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.key.is_empty() {
os.write_bytes(2, &self.key)?;
}
if !self.value.is_empty() {
os.write_bytes(3, &self.value)?;
}
if !self.cf.is_empty() {
os.write_string(4, &self.cf)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RawPutRequest {
RawPutRequest::new()
}
fn default_instance() -> &'static RawPutRequest {
static mut instance: ::protobuf::lazy::Lazy<RawPutRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RawPutRequest,
};
unsafe {
instance.get(RawPutRequest::new)
}
}
}
impl ::protobuf::Clear for RawPutRequest {
fn clear(&mut self) {
self.context.clear();
self.key.clear();
self.value.clear();
self.cf.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RawPutRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.key, "key", buf);
::protobuf::PbPrint::fmt(&self.value, "value", buf);
::protobuf::PbPrint::fmt(&self.cf, "cf", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RawPutRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.key, "key", &mut s);
::protobuf::PbPrint::fmt(&self.value, "value", &mut s);
::protobuf::PbPrint::fmt(&self.cf, "cf", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RawPutRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RawPutResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RawPutResponse {
fn default() -> &'a RawPutResponse {
<RawPutResponse as ::protobuf::Message>::default_instance()
}
}
impl RawPutResponse {
pub fn new() -> RawPutResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &str {
&self.error
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn set_error(&mut self, v: ::std::string::String) {
self.error = v;
}
pub fn mut_error(&mut self) -> &mut ::std::string::String {
&mut self.error
}
pub fn take_error(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error, ::std::string::String::new())
}
}
impl ::protobuf::Message for RawPutResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.error.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.error);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.error.is_empty() {
os.write_string(2, &self.error)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RawPutResponse {
RawPutResponse::new()
}
fn default_instance() -> &'static RawPutResponse {
static mut instance: ::protobuf::lazy::Lazy<RawPutResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RawPutResponse,
};
unsafe {
instance.get(RawPutResponse::new)
}
}
}
impl ::protobuf::Clear for RawPutResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RawPutResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RawPutResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RawPutResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RawBatchPutRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub pairs: ::protobuf::RepeatedField<KvPair>,
pub cf: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RawBatchPutRequest {
fn default() -> &'a RawBatchPutRequest {
<RawBatchPutRequest as ::protobuf::Message>::default_instance()
}
}
impl RawBatchPutRequest {
pub fn new() -> RawBatchPutRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_pairs(&self) -> &[KvPair] {
&self.pairs
}
pub fn clear_pairs(&mut self) {
self.pairs.clear();
}
pub fn set_pairs(&mut self, v: ::protobuf::RepeatedField<KvPair>) {
self.pairs = v;
}
pub fn mut_pairs(&mut self) -> &mut ::protobuf::RepeatedField<KvPair> {
&mut self.pairs
}
pub fn take_pairs(&mut self) -> ::protobuf::RepeatedField<KvPair> {
::std::mem::replace(&mut self.pairs, ::protobuf::RepeatedField::new())
}
pub fn get_cf(&self) -> &str {
&self.cf
}
pub fn clear_cf(&mut self) {
self.cf.clear();
}
pub fn set_cf(&mut self, v: ::std::string::String) {
self.cf = v;
}
pub fn mut_cf(&mut self) -> &mut ::std::string::String {
&mut self.cf
}
pub fn take_cf(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.cf, ::std::string::String::new())
}
}
impl ::protobuf::Message for RawBatchPutRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
for v in &self.pairs {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.pairs)?;
},
3 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.cf)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.pairs {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if !self.cf.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.cf);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.pairs {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
if !self.cf.is_empty() {
os.write_string(3, &self.cf)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RawBatchPutRequest {
RawBatchPutRequest::new()
}
fn default_instance() -> &'static RawBatchPutRequest {
static mut instance: ::protobuf::lazy::Lazy<RawBatchPutRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RawBatchPutRequest,
};
unsafe {
instance.get(RawBatchPutRequest::new)
}
}
}
impl ::protobuf::Clear for RawBatchPutRequest {
fn clear(&mut self) {
self.context.clear();
self.pairs.clear();
self.cf.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RawBatchPutRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.pairs, "pairs", buf);
::protobuf::PbPrint::fmt(&self.cf, "cf", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RawBatchPutRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.pairs, "pairs", &mut s);
::protobuf::PbPrint::fmt(&self.cf, "cf", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RawBatchPutRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RawBatchPutResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RawBatchPutResponse {
fn default() -> &'a RawBatchPutResponse {
<RawBatchPutResponse as ::protobuf::Message>::default_instance()
}
}
impl RawBatchPutResponse {
pub fn new() -> RawBatchPutResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &str {
&self.error
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn set_error(&mut self, v: ::std::string::String) {
self.error = v;
}
pub fn mut_error(&mut self) -> &mut ::std::string::String {
&mut self.error
}
pub fn take_error(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error, ::std::string::String::new())
}
}
impl ::protobuf::Message for RawBatchPutResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.error.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.error);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.error.is_empty() {
os.write_string(2, &self.error)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RawBatchPutResponse {
RawBatchPutResponse::new()
}
fn default_instance() -> &'static RawBatchPutResponse {
static mut instance: ::protobuf::lazy::Lazy<RawBatchPutResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RawBatchPutResponse,
};
unsafe {
instance.get(RawBatchPutResponse::new)
}
}
}
impl ::protobuf::Clear for RawBatchPutResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RawBatchPutResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RawBatchPutResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RawBatchPutResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RawDeleteRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub key: ::std::vec::Vec<u8>,
pub cf: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RawDeleteRequest {
fn default() -> &'a RawDeleteRequest {
<RawDeleteRequest as ::protobuf::Message>::default_instance()
}
}
impl RawDeleteRequest {
pub fn new() -> RawDeleteRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_key(&self) -> &[u8] {
&self.key
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
self.key = v;
}
pub fn mut_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.key
}
pub fn take_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.key, ::std::vec::Vec::new())
}
pub fn get_cf(&self) -> &str {
&self.cf
}
pub fn clear_cf(&mut self) {
self.cf.clear();
}
pub fn set_cf(&mut self, v: ::std::string::String) {
self.cf = v;
}
pub fn mut_cf(&mut self) -> &mut ::std::string::String {
&mut self.cf
}
pub fn take_cf(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.cf, ::std::string::String::new())
}
}
impl ::protobuf::Message for RawDeleteRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?;
},
3 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.cf)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.key);
}
if !self.cf.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.cf);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.key.is_empty() {
os.write_bytes(2, &self.key)?;
}
if !self.cf.is_empty() {
os.write_string(3, &self.cf)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RawDeleteRequest {
RawDeleteRequest::new()
}
fn default_instance() -> &'static RawDeleteRequest {
static mut instance: ::protobuf::lazy::Lazy<RawDeleteRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RawDeleteRequest,
};
unsafe {
instance.get(RawDeleteRequest::new)
}
}
}
impl ::protobuf::Clear for RawDeleteRequest {
fn clear(&mut self) {
self.context.clear();
self.key.clear();
self.cf.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RawDeleteRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.key, "key", buf);
::protobuf::PbPrint::fmt(&self.cf, "cf", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RawDeleteRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.key, "key", &mut s);
::protobuf::PbPrint::fmt(&self.cf, "cf", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RawDeleteRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RawDeleteResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RawDeleteResponse {
fn default() -> &'a RawDeleteResponse {
<RawDeleteResponse as ::protobuf::Message>::default_instance()
}
}
impl RawDeleteResponse {
pub fn new() -> RawDeleteResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &str {
&self.error
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn set_error(&mut self, v: ::std::string::String) {
self.error = v;
}
pub fn mut_error(&mut self) -> &mut ::std::string::String {
&mut self.error
}
pub fn take_error(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error, ::std::string::String::new())
}
}
impl ::protobuf::Message for RawDeleteResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.error.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.error);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.error.is_empty() {
os.write_string(2, &self.error)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RawDeleteResponse {
RawDeleteResponse::new()
}
fn default_instance() -> &'static RawDeleteResponse {
static mut instance: ::protobuf::lazy::Lazy<RawDeleteResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RawDeleteResponse,
};
unsafe {
instance.get(RawDeleteResponse::new)
}
}
}
impl ::protobuf::Clear for RawDeleteResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RawDeleteResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RawDeleteResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RawDeleteResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RawBatchDeleteRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub keys: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
pub cf: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RawBatchDeleteRequest {
fn default() -> &'a RawBatchDeleteRequest {
<RawBatchDeleteRequest as ::protobuf::Message>::default_instance()
}
}
impl RawBatchDeleteRequest {
pub fn new() -> RawBatchDeleteRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_keys(&self) -> &[::std::vec::Vec<u8>] {
&self.keys
}
pub fn clear_keys(&mut self) {
self.keys.clear();
}
pub fn set_keys(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
self.keys = v;
}
pub fn mut_keys(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
&mut self.keys
}
pub fn take_keys(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
::std::mem::replace(&mut self.keys, ::protobuf::RepeatedField::new())
}
pub fn get_cf(&self) -> &str {
&self.cf
}
pub fn clear_cf(&mut self) {
self.cf.clear();
}
pub fn set_cf(&mut self, v: ::std::string::String) {
self.cf = v;
}
pub fn mut_cf(&mut self) -> &mut ::std::string::String {
&mut self.cf
}
pub fn take_cf(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.cf, ::std::string::String::new())
}
}
impl ::protobuf::Message for RawBatchDeleteRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.keys)?;
},
3 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.cf)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.keys {
my_size += ::protobuf::rt::bytes_size(2, &value);
};
if !self.cf.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.cf);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.keys {
os.write_bytes(2, &v)?;
};
if !self.cf.is_empty() {
os.write_string(3, &self.cf)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RawBatchDeleteRequest {
RawBatchDeleteRequest::new()
}
fn default_instance() -> &'static RawBatchDeleteRequest {
static mut instance: ::protobuf::lazy::Lazy<RawBatchDeleteRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RawBatchDeleteRequest,
};
unsafe {
instance.get(RawBatchDeleteRequest::new)
}
}
}
impl ::protobuf::Clear for RawBatchDeleteRequest {
fn clear(&mut self) {
self.context.clear();
self.keys.clear();
self.cf.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RawBatchDeleteRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.keys, "keys", buf);
::protobuf::PbPrint::fmt(&self.cf, "cf", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RawBatchDeleteRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.keys, "keys", &mut s);
::protobuf::PbPrint::fmt(&self.cf, "cf", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RawBatchDeleteRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RawBatchDeleteResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RawBatchDeleteResponse {
fn default() -> &'a RawBatchDeleteResponse {
<RawBatchDeleteResponse as ::protobuf::Message>::default_instance()
}
}
impl RawBatchDeleteResponse {
pub fn new() -> RawBatchDeleteResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &str {
&self.error
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn set_error(&mut self, v: ::std::string::String) {
self.error = v;
}
pub fn mut_error(&mut self) -> &mut ::std::string::String {
&mut self.error
}
pub fn take_error(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error, ::std::string::String::new())
}
}
impl ::protobuf::Message for RawBatchDeleteResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.error.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.error);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.error.is_empty() {
os.write_string(2, &self.error)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RawBatchDeleteResponse {
RawBatchDeleteResponse::new()
}
fn default_instance() -> &'static RawBatchDeleteResponse {
static mut instance: ::protobuf::lazy::Lazy<RawBatchDeleteResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RawBatchDeleteResponse,
};
unsafe {
instance.get(RawBatchDeleteResponse::new)
}
}
}
impl ::protobuf::Clear for RawBatchDeleteResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RawBatchDeleteResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RawBatchDeleteResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RawBatchDeleteResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RawScanRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub start_key: ::std::vec::Vec<u8>,
pub limit: u32,
pub key_only: bool,
pub cf: ::std::string::String,
pub reverse: bool,
pub end_key: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RawScanRequest {
fn default() -> &'a RawScanRequest {
<RawScanRequest as ::protobuf::Message>::default_instance()
}
}
impl RawScanRequest {
pub fn new() -> RawScanRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_start_key(&self) -> &[u8] {
&self.start_key
}
pub fn clear_start_key(&mut self) {
self.start_key.clear();
}
pub fn set_start_key(&mut self, v: ::std::vec::Vec<u8>) {
self.start_key = v;
}
pub fn mut_start_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.start_key
}
pub fn take_start_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.start_key, ::std::vec::Vec::new())
}
pub fn get_limit(&self) -> u32 {
self.limit
}
pub fn clear_limit(&mut self) {
self.limit = 0;
}
pub fn set_limit(&mut self, v: u32) {
self.limit = v;
}
pub fn get_key_only(&self) -> bool {
self.key_only
}
pub fn clear_key_only(&mut self) {
self.key_only = false;
}
pub fn set_key_only(&mut self, v: bool) {
self.key_only = v;
}
pub fn get_cf(&self) -> &str {
&self.cf
}
pub fn clear_cf(&mut self) {
self.cf.clear();
}
pub fn set_cf(&mut self, v: ::std::string::String) {
self.cf = v;
}
pub fn mut_cf(&mut self) -> &mut ::std::string::String {
&mut self.cf
}
pub fn take_cf(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.cf, ::std::string::String::new())
}
pub fn get_reverse(&self) -> bool {
self.reverse
}
pub fn clear_reverse(&mut self) {
self.reverse = false;
}
pub fn set_reverse(&mut self, v: bool) {
self.reverse = v;
}
pub fn get_end_key(&self) -> &[u8] {
&self.end_key
}
pub fn clear_end_key(&mut self) {
self.end_key.clear();
}
pub fn set_end_key(&mut self, v: ::std::vec::Vec<u8>) {
self.end_key = v;
}
pub fn mut_end_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.end_key
}
pub fn take_end_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.end_key, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for RawScanRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.start_key)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.limit = tmp;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.key_only = tmp;
},
5 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.cf)?;
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.reverse = tmp;
},
7 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.end_key)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.start_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.start_key);
}
if self.limit != 0 {
my_size += ::protobuf::rt::value_size(3, self.limit, ::protobuf::wire_format::WireTypeVarint);
}
if self.key_only != false {
my_size += 2;
}
if !self.cf.is_empty() {
my_size += ::protobuf::rt::string_size(5, &self.cf);
}
if self.reverse != false {
my_size += 2;
}
if !self.end_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(7, &self.end_key);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.start_key.is_empty() {
os.write_bytes(2, &self.start_key)?;
}
if self.limit != 0 {
os.write_uint32(3, self.limit)?;
}
if self.key_only != false {
os.write_bool(4, self.key_only)?;
}
if !self.cf.is_empty() {
os.write_string(5, &self.cf)?;
}
if self.reverse != false {
os.write_bool(6, self.reverse)?;
}
if !self.end_key.is_empty() {
os.write_bytes(7, &self.end_key)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RawScanRequest {
RawScanRequest::new()
}
fn default_instance() -> &'static RawScanRequest {
static mut instance: ::protobuf::lazy::Lazy<RawScanRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RawScanRequest,
};
unsafe {
instance.get(RawScanRequest::new)
}
}
}
impl ::protobuf::Clear for RawScanRequest {
fn clear(&mut self) {
self.context.clear();
self.start_key.clear();
self.limit = 0;
self.key_only = false;
self.cf.clear();
self.reverse = false;
self.end_key.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RawScanRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.start_key, "start_key", buf);
::protobuf::PbPrint::fmt(&self.limit, "limit", buf);
::protobuf::PbPrint::fmt(&self.key_only, "key_only", buf);
::protobuf::PbPrint::fmt(&self.cf, "cf", buf);
::protobuf::PbPrint::fmt(&self.reverse, "reverse", buf);
::protobuf::PbPrint::fmt(&self.end_key, "end_key", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RawScanRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.start_key, "start_key", &mut s);
::protobuf::PbPrint::fmt(&self.limit, "limit", &mut s);
::protobuf::PbPrint::fmt(&self.key_only, "key_only", &mut s);
::protobuf::PbPrint::fmt(&self.cf, "cf", &mut s);
::protobuf::PbPrint::fmt(&self.reverse, "reverse", &mut s);
::protobuf::PbPrint::fmt(&self.end_key, "end_key", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RawScanRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RawScanResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub kvs: ::protobuf::RepeatedField<KvPair>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RawScanResponse {
fn default() -> &'a RawScanResponse {
<RawScanResponse as ::protobuf::Message>::default_instance()
}
}
impl RawScanResponse {
pub fn new() -> RawScanResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_kvs(&self) -> &[KvPair] {
&self.kvs
}
pub fn clear_kvs(&mut self) {
self.kvs.clear();
}
pub fn set_kvs(&mut self, v: ::protobuf::RepeatedField<KvPair>) {
self.kvs = v;
}
pub fn mut_kvs(&mut self) -> &mut ::protobuf::RepeatedField<KvPair> {
&mut self.kvs
}
pub fn take_kvs(&mut self) -> ::protobuf::RepeatedField<KvPair> {
::std::mem::replace(&mut self.kvs, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for RawScanResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.kvs {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.kvs)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.kvs {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.kvs {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RawScanResponse {
RawScanResponse::new()
}
fn default_instance() -> &'static RawScanResponse {
static mut instance: ::protobuf::lazy::Lazy<RawScanResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RawScanResponse,
};
unsafe {
instance.get(RawScanResponse::new)
}
}
}
impl ::protobuf::Clear for RawScanResponse {
fn clear(&mut self) {
self.region_error.clear();
self.kvs.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RawScanResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.kvs, "kvs", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RawScanResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.kvs, "kvs", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RawScanResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RawDeleteRangeRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub start_key: ::std::vec::Vec<u8>,
pub end_key: ::std::vec::Vec<u8>,
pub cf: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RawDeleteRangeRequest {
fn default() -> &'a RawDeleteRangeRequest {
<RawDeleteRangeRequest as ::protobuf::Message>::default_instance()
}
}
impl RawDeleteRangeRequest {
pub fn new() -> RawDeleteRangeRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_start_key(&self) -> &[u8] {
&self.start_key
}
pub fn clear_start_key(&mut self) {
self.start_key.clear();
}
pub fn set_start_key(&mut self, v: ::std::vec::Vec<u8>) {
self.start_key = v;
}
pub fn mut_start_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.start_key
}
pub fn take_start_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.start_key, ::std::vec::Vec::new())
}
pub fn get_end_key(&self) -> &[u8] {
&self.end_key
}
pub fn clear_end_key(&mut self) {
self.end_key.clear();
}
pub fn set_end_key(&mut self, v: ::std::vec::Vec<u8>) {
self.end_key = v;
}
pub fn mut_end_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.end_key
}
pub fn take_end_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.end_key, ::std::vec::Vec::new())
}
pub fn get_cf(&self) -> &str {
&self.cf
}
pub fn clear_cf(&mut self) {
self.cf.clear();
}
pub fn set_cf(&mut self, v: ::std::string::String) {
self.cf = v;
}
pub fn mut_cf(&mut self) -> &mut ::std::string::String {
&mut self.cf
}
pub fn take_cf(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.cf, ::std::string::String::new())
}
}
impl ::protobuf::Message for RawDeleteRangeRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.start_key)?;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.end_key)?;
},
4 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.cf)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.start_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.start_key);
}
if !self.end_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.end_key);
}
if !self.cf.is_empty() {
my_size += ::protobuf::rt::string_size(4, &self.cf);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.start_key.is_empty() {
os.write_bytes(2, &self.start_key)?;
}
if !self.end_key.is_empty() {
os.write_bytes(3, &self.end_key)?;
}
if !self.cf.is_empty() {
os.write_string(4, &self.cf)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RawDeleteRangeRequest {
RawDeleteRangeRequest::new()
}
fn default_instance() -> &'static RawDeleteRangeRequest {
static mut instance: ::protobuf::lazy::Lazy<RawDeleteRangeRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RawDeleteRangeRequest,
};
unsafe {
instance.get(RawDeleteRangeRequest::new)
}
}
}
impl ::protobuf::Clear for RawDeleteRangeRequest {
fn clear(&mut self) {
self.context.clear();
self.start_key.clear();
self.end_key.clear();
self.cf.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RawDeleteRangeRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.start_key, "start_key", buf);
::protobuf::PbPrint::fmt(&self.end_key, "end_key", buf);
::protobuf::PbPrint::fmt(&self.cf, "cf", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RawDeleteRangeRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.start_key, "start_key", &mut s);
::protobuf::PbPrint::fmt(&self.end_key, "end_key", &mut s);
::protobuf::PbPrint::fmt(&self.cf, "cf", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RawDeleteRangeRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RawDeleteRangeResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RawDeleteRangeResponse {
fn default() -> &'a RawDeleteRangeResponse {
<RawDeleteRangeResponse as ::protobuf::Message>::default_instance()
}
}
impl RawDeleteRangeResponse {
pub fn new() -> RawDeleteRangeResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &str {
&self.error
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn set_error(&mut self, v: ::std::string::String) {
self.error = v;
}
pub fn mut_error(&mut self) -> &mut ::std::string::String {
&mut self.error
}
pub fn take_error(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error, ::std::string::String::new())
}
}
impl ::protobuf::Message for RawDeleteRangeResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.error.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.error);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.error.is_empty() {
os.write_string(2, &self.error)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RawDeleteRangeResponse {
RawDeleteRangeResponse::new()
}
fn default_instance() -> &'static RawDeleteRangeResponse {
static mut instance: ::protobuf::lazy::Lazy<RawDeleteRangeResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RawDeleteRangeResponse,
};
unsafe {
instance.get(RawDeleteRangeResponse::new)
}
}
}
impl ::protobuf::Clear for RawDeleteRangeResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RawDeleteRangeResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RawDeleteRangeResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RawDeleteRangeResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RawBatchScanRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub ranges: ::protobuf::RepeatedField<KeyRange>,
pub each_limit: u32,
pub key_only: bool,
pub cf: ::std::string::String,
pub reverse: bool,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RawBatchScanRequest {
fn default() -> &'a RawBatchScanRequest {
<RawBatchScanRequest as ::protobuf::Message>::default_instance()
}
}
impl RawBatchScanRequest {
pub fn new() -> RawBatchScanRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_ranges(&self) -> &[KeyRange] {
&self.ranges
}
pub fn clear_ranges(&mut self) {
self.ranges.clear();
}
pub fn set_ranges(&mut self, v: ::protobuf::RepeatedField<KeyRange>) {
self.ranges = v;
}
pub fn mut_ranges(&mut self) -> &mut ::protobuf::RepeatedField<KeyRange> {
&mut self.ranges
}
pub fn take_ranges(&mut self) -> ::protobuf::RepeatedField<KeyRange> {
::std::mem::replace(&mut self.ranges, ::protobuf::RepeatedField::new())
}
pub fn get_each_limit(&self) -> u32 {
self.each_limit
}
pub fn clear_each_limit(&mut self) {
self.each_limit = 0;
}
pub fn set_each_limit(&mut self, v: u32) {
self.each_limit = v;
}
pub fn get_key_only(&self) -> bool {
self.key_only
}
pub fn clear_key_only(&mut self) {
self.key_only = false;
}
pub fn set_key_only(&mut self, v: bool) {
self.key_only = v;
}
pub fn get_cf(&self) -> &str {
&self.cf
}
pub fn clear_cf(&mut self) {
self.cf.clear();
}
pub fn set_cf(&mut self, v: ::std::string::String) {
self.cf = v;
}
pub fn mut_cf(&mut self) -> &mut ::std::string::String {
&mut self.cf
}
pub fn take_cf(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.cf, ::std::string::String::new())
}
pub fn get_reverse(&self) -> bool {
self.reverse
}
pub fn clear_reverse(&mut self) {
self.reverse = false;
}
pub fn set_reverse(&mut self, v: bool) {
self.reverse = v;
}
}
impl ::protobuf::Message for RawBatchScanRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
for v in &self.ranges {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.ranges)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.each_limit = tmp;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.key_only = tmp;
},
5 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.cf)?;
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.reverse = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.ranges {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if self.each_limit != 0 {
my_size += ::protobuf::rt::value_size(3, self.each_limit, ::protobuf::wire_format::WireTypeVarint);
}
if self.key_only != false {
my_size += 2;
}
if !self.cf.is_empty() {
my_size += ::protobuf::rt::string_size(5, &self.cf);
}
if self.reverse != false {
my_size += 2;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.ranges {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
if self.each_limit != 0 {
os.write_uint32(3, self.each_limit)?;
}
if self.key_only != false {
os.write_bool(4, self.key_only)?;
}
if !self.cf.is_empty() {
os.write_string(5, &self.cf)?;
}
if self.reverse != false {
os.write_bool(6, self.reverse)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RawBatchScanRequest {
RawBatchScanRequest::new()
}
fn default_instance() -> &'static RawBatchScanRequest {
static mut instance: ::protobuf::lazy::Lazy<RawBatchScanRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RawBatchScanRequest,
};
unsafe {
instance.get(RawBatchScanRequest::new)
}
}
}
impl ::protobuf::Clear for RawBatchScanRequest {
fn clear(&mut self) {
self.context.clear();
self.ranges.clear();
self.each_limit = 0;
self.key_only = false;
self.cf.clear();
self.reverse = false;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RawBatchScanRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.ranges, "ranges", buf);
::protobuf::PbPrint::fmt(&self.each_limit, "each_limit", buf);
::protobuf::PbPrint::fmt(&self.key_only, "key_only", buf);
::protobuf::PbPrint::fmt(&self.cf, "cf", buf);
::protobuf::PbPrint::fmt(&self.reverse, "reverse", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RawBatchScanRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.ranges, "ranges", &mut s);
::protobuf::PbPrint::fmt(&self.each_limit, "each_limit", &mut s);
::protobuf::PbPrint::fmt(&self.key_only, "key_only", &mut s);
::protobuf::PbPrint::fmt(&self.cf, "cf", &mut s);
::protobuf::PbPrint::fmt(&self.reverse, "reverse", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RawBatchScanRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RawBatchScanResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub kvs: ::protobuf::RepeatedField<KvPair>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RawBatchScanResponse {
fn default() -> &'a RawBatchScanResponse {
<RawBatchScanResponse as ::protobuf::Message>::default_instance()
}
}
impl RawBatchScanResponse {
pub fn new() -> RawBatchScanResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_kvs(&self) -> &[KvPair] {
&self.kvs
}
pub fn clear_kvs(&mut self) {
self.kvs.clear();
}
pub fn set_kvs(&mut self, v: ::protobuf::RepeatedField<KvPair>) {
self.kvs = v;
}
pub fn mut_kvs(&mut self) -> &mut ::protobuf::RepeatedField<KvPair> {
&mut self.kvs
}
pub fn take_kvs(&mut self) -> ::protobuf::RepeatedField<KvPair> {
::std::mem::replace(&mut self.kvs, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for RawBatchScanResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.kvs {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.kvs)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.kvs {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.kvs {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RawBatchScanResponse {
RawBatchScanResponse::new()
}
fn default_instance() -> &'static RawBatchScanResponse {
static mut instance: ::protobuf::lazy::Lazy<RawBatchScanResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RawBatchScanResponse,
};
unsafe {
instance.get(RawBatchScanResponse::new)
}
}
}
impl ::protobuf::Clear for RawBatchScanResponse {
fn clear(&mut self) {
self.region_error.clear();
self.kvs.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RawBatchScanResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.kvs, "kvs", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RawBatchScanResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.kvs, "kvs", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RawBatchScanResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct UnsafeDestroyRangeRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub start_key: ::std::vec::Vec<u8>,
pub end_key: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a UnsafeDestroyRangeRequest {
fn default() -> &'a UnsafeDestroyRangeRequest {
<UnsafeDestroyRangeRequest as ::protobuf::Message>::default_instance()
}
}
impl UnsafeDestroyRangeRequest {
pub fn new() -> UnsafeDestroyRangeRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_start_key(&self) -> &[u8] {
&self.start_key
}
pub fn clear_start_key(&mut self) {
self.start_key.clear();
}
pub fn set_start_key(&mut self, v: ::std::vec::Vec<u8>) {
self.start_key = v;
}
pub fn mut_start_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.start_key
}
pub fn take_start_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.start_key, ::std::vec::Vec::new())
}
pub fn get_end_key(&self) -> &[u8] {
&self.end_key
}
pub fn clear_end_key(&mut self) {
self.end_key.clear();
}
pub fn set_end_key(&mut self, v: ::std::vec::Vec<u8>) {
self.end_key = v;
}
pub fn mut_end_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.end_key
}
pub fn take_end_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.end_key, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for UnsafeDestroyRangeRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.start_key)?;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.end_key)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.start_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.start_key);
}
if !self.end_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.end_key);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.start_key.is_empty() {
os.write_bytes(2, &self.start_key)?;
}
if !self.end_key.is_empty() {
os.write_bytes(3, &self.end_key)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> UnsafeDestroyRangeRequest {
UnsafeDestroyRangeRequest::new()
}
fn default_instance() -> &'static UnsafeDestroyRangeRequest {
static mut instance: ::protobuf::lazy::Lazy<UnsafeDestroyRangeRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const UnsafeDestroyRangeRequest,
};
unsafe {
instance.get(UnsafeDestroyRangeRequest::new)
}
}
}
impl ::protobuf::Clear for UnsafeDestroyRangeRequest {
fn clear(&mut self) {
self.context.clear();
self.start_key.clear();
self.end_key.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for UnsafeDestroyRangeRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.start_key, "start_key", buf);
::protobuf::PbPrint::fmt(&self.end_key, "end_key", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for UnsafeDestroyRangeRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.start_key, "start_key", &mut s);
::protobuf::PbPrint::fmt(&self.end_key, "end_key", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for UnsafeDestroyRangeRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct UnsafeDestroyRangeResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a UnsafeDestroyRangeResponse {
fn default() -> &'a UnsafeDestroyRangeResponse {
<UnsafeDestroyRangeResponse as ::protobuf::Message>::default_instance()
}
}
impl UnsafeDestroyRangeResponse {
pub fn new() -> UnsafeDestroyRangeResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &str {
&self.error
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn set_error(&mut self, v: ::std::string::String) {
self.error = v;
}
pub fn mut_error(&mut self) -> &mut ::std::string::String {
&mut self.error
}
pub fn take_error(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error, ::std::string::String::new())
}
}
impl ::protobuf::Message for UnsafeDestroyRangeResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.error.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.error);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.error.is_empty() {
os.write_string(2, &self.error)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> UnsafeDestroyRangeResponse {
UnsafeDestroyRangeResponse::new()
}
fn default_instance() -> &'static UnsafeDestroyRangeResponse {
static mut instance: ::protobuf::lazy::Lazy<UnsafeDestroyRangeResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const UnsafeDestroyRangeResponse,
};
unsafe {
instance.get(UnsafeDestroyRangeResponse::new)
}
}
}
impl ::protobuf::Clear for UnsafeDestroyRangeResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for UnsafeDestroyRangeResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for UnsafeDestroyRangeResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for UnsafeDestroyRangeResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RegisterLockObserverRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub max_ts: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RegisterLockObserverRequest {
fn default() -> &'a RegisterLockObserverRequest {
<RegisterLockObserverRequest as ::protobuf::Message>::default_instance()
}
}
impl RegisterLockObserverRequest {
pub fn new() -> RegisterLockObserverRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_max_ts(&self) -> u64 {
self.max_ts
}
pub fn clear_max_ts(&mut self) {
self.max_ts = 0;
}
pub fn set_max_ts(&mut self, v: u64) {
self.max_ts = v;
}
}
impl ::protobuf::Message for RegisterLockObserverRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.max_ts = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.max_ts != 0 {
my_size += ::protobuf::rt::value_size(2, self.max_ts, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.max_ts != 0 {
os.write_uint64(2, self.max_ts)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RegisterLockObserverRequest {
RegisterLockObserverRequest::new()
}
fn default_instance() -> &'static RegisterLockObserverRequest {
static mut instance: ::protobuf::lazy::Lazy<RegisterLockObserverRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RegisterLockObserverRequest,
};
unsafe {
instance.get(RegisterLockObserverRequest::new)
}
}
}
impl ::protobuf::Clear for RegisterLockObserverRequest {
fn clear(&mut self) {
self.context.clear();
self.max_ts = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RegisterLockObserverRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.max_ts, "max_ts", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RegisterLockObserverRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.max_ts, "max_ts", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RegisterLockObserverRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RegisterLockObserverResponse {
pub error: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RegisterLockObserverResponse {
fn default() -> &'a RegisterLockObserverResponse {
<RegisterLockObserverResponse as ::protobuf::Message>::default_instance()
}
}
impl RegisterLockObserverResponse {
pub fn new() -> RegisterLockObserverResponse {
::std::default::Default::default()
}
pub fn get_error(&self) -> &str {
&self.error
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn set_error(&mut self, v: ::std::string::String) {
self.error = v;
}
pub fn mut_error(&mut self) -> &mut ::std::string::String {
&mut self.error
}
pub fn take_error(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error, ::std::string::String::new())
}
}
impl ::protobuf::Message for RegisterLockObserverResponse {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.error.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.error);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.error.is_empty() {
os.write_string(1, &self.error)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RegisterLockObserverResponse {
RegisterLockObserverResponse::new()
}
fn default_instance() -> &'static RegisterLockObserverResponse {
static mut instance: ::protobuf::lazy::Lazy<RegisterLockObserverResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RegisterLockObserverResponse,
};
unsafe {
instance.get(RegisterLockObserverResponse::new)
}
}
}
impl ::protobuf::Clear for RegisterLockObserverResponse {
fn clear(&mut self) {
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RegisterLockObserverResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RegisterLockObserverResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RegisterLockObserverResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CheckLockObserverRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub max_ts: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CheckLockObserverRequest {
fn default() -> &'a CheckLockObserverRequest {
<CheckLockObserverRequest as ::protobuf::Message>::default_instance()
}
}
impl CheckLockObserverRequest {
pub fn new() -> CheckLockObserverRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_max_ts(&self) -> u64 {
self.max_ts
}
pub fn clear_max_ts(&mut self) {
self.max_ts = 0;
}
pub fn set_max_ts(&mut self, v: u64) {
self.max_ts = v;
}
}
impl ::protobuf::Message for CheckLockObserverRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.max_ts = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.max_ts != 0 {
my_size += ::protobuf::rt::value_size(2, self.max_ts, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.max_ts != 0 {
os.write_uint64(2, self.max_ts)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CheckLockObserverRequest {
CheckLockObserverRequest::new()
}
fn default_instance() -> &'static CheckLockObserverRequest {
static mut instance: ::protobuf::lazy::Lazy<CheckLockObserverRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CheckLockObserverRequest,
};
unsafe {
instance.get(CheckLockObserverRequest::new)
}
}
}
impl ::protobuf::Clear for CheckLockObserverRequest {
fn clear(&mut self) {
self.context.clear();
self.max_ts = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for CheckLockObserverRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.max_ts, "max_ts", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for CheckLockObserverRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.max_ts, "max_ts", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for CheckLockObserverRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CheckLockObserverResponse {
pub error: ::std::string::String,
pub is_clean: bool,
pub locks: ::protobuf::RepeatedField<LockInfo>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CheckLockObserverResponse {
fn default() -> &'a CheckLockObserverResponse {
<CheckLockObserverResponse as ::protobuf::Message>::default_instance()
}
}
impl CheckLockObserverResponse {
pub fn new() -> CheckLockObserverResponse {
::std::default::Default::default()
}
pub fn get_error(&self) -> &str {
&self.error
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn set_error(&mut self, v: ::std::string::String) {
self.error = v;
}
pub fn mut_error(&mut self) -> &mut ::std::string::String {
&mut self.error
}
pub fn take_error(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error, ::std::string::String::new())
}
pub fn get_is_clean(&self) -> bool {
self.is_clean
}
pub fn clear_is_clean(&mut self) {
self.is_clean = false;
}
pub fn set_is_clean(&mut self, v: bool) {
self.is_clean = v;
}
pub fn get_locks(&self) -> &[LockInfo] {
&self.locks
}
pub fn clear_locks(&mut self) {
self.locks.clear();
}
pub fn set_locks(&mut self, v: ::protobuf::RepeatedField<LockInfo>) {
self.locks = v;
}
pub fn mut_locks(&mut self) -> &mut ::protobuf::RepeatedField<LockInfo> {
&mut self.locks
}
pub fn take_locks(&mut self) -> ::protobuf::RepeatedField<LockInfo> {
::std::mem::replace(&mut self.locks, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for CheckLockObserverResponse {
fn is_initialized(&self) -> bool {
for v in &self.locks {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.error)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.is_clean = tmp;
},
3 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.locks)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.error.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.error);
}
if self.is_clean != false {
my_size += 2;
}
for value in &self.locks {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.error.is_empty() {
os.write_string(1, &self.error)?;
}
if self.is_clean != false {
os.write_bool(2, self.is_clean)?;
}
for v in &self.locks {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CheckLockObserverResponse {
CheckLockObserverResponse::new()
}
fn default_instance() -> &'static CheckLockObserverResponse {
static mut instance: ::protobuf::lazy::Lazy<CheckLockObserverResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CheckLockObserverResponse,
};
unsafe {
instance.get(CheckLockObserverResponse::new)
}
}
}
impl ::protobuf::Clear for CheckLockObserverResponse {
fn clear(&mut self) {
self.error.clear();
self.is_clean = false;
self.locks.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for CheckLockObserverResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.error, "error", buf);
::protobuf::PbPrint::fmt(&self.is_clean, "is_clean", buf);
::protobuf::PbPrint::fmt(&self.locks, "locks", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for CheckLockObserverResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
::protobuf::PbPrint::fmt(&self.is_clean, "is_clean", &mut s);
::protobuf::PbPrint::fmt(&self.locks, "locks", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for CheckLockObserverResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RemoveLockObserverRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub max_ts: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RemoveLockObserverRequest {
fn default() -> &'a RemoveLockObserverRequest {
<RemoveLockObserverRequest as ::protobuf::Message>::default_instance()
}
}
impl RemoveLockObserverRequest {
pub fn new() -> RemoveLockObserverRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_max_ts(&self) -> u64 {
self.max_ts
}
pub fn clear_max_ts(&mut self) {
self.max_ts = 0;
}
pub fn set_max_ts(&mut self, v: u64) {
self.max_ts = v;
}
}
impl ::protobuf::Message for RemoveLockObserverRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.max_ts = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.max_ts != 0 {
my_size += ::protobuf::rt::value_size(2, self.max_ts, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.max_ts != 0 {
os.write_uint64(2, self.max_ts)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RemoveLockObserverRequest {
RemoveLockObserverRequest::new()
}
fn default_instance() -> &'static RemoveLockObserverRequest {
static mut instance: ::protobuf::lazy::Lazy<RemoveLockObserverRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RemoveLockObserverRequest,
};
unsafe {
instance.get(RemoveLockObserverRequest::new)
}
}
}
impl ::protobuf::Clear for RemoveLockObserverRequest {
fn clear(&mut self) {
self.context.clear();
self.max_ts = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RemoveLockObserverRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.max_ts, "max_ts", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RemoveLockObserverRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.max_ts, "max_ts", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RemoveLockObserverRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RemoveLockObserverResponse {
pub error: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RemoveLockObserverResponse {
fn default() -> &'a RemoveLockObserverResponse {
<RemoveLockObserverResponse as ::protobuf::Message>::default_instance()
}
}
impl RemoveLockObserverResponse {
pub fn new() -> RemoveLockObserverResponse {
::std::default::Default::default()
}
pub fn get_error(&self) -> &str {
&self.error
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn set_error(&mut self, v: ::std::string::String) {
self.error = v;
}
pub fn mut_error(&mut self) -> &mut ::std::string::String {
&mut self.error
}
pub fn take_error(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error, ::std::string::String::new())
}
}
impl ::protobuf::Message for RemoveLockObserverResponse {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.error.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.error);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.error.is_empty() {
os.write_string(1, &self.error)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RemoveLockObserverResponse {
RemoveLockObserverResponse::new()
}
fn default_instance() -> &'static RemoveLockObserverResponse {
static mut instance: ::protobuf::lazy::Lazy<RemoveLockObserverResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const RemoveLockObserverResponse,
};
unsafe {
instance.get(RemoveLockObserverResponse::new)
}
}
}
impl ::protobuf::Clear for RemoveLockObserverResponse {
fn clear(&mut self) {
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for RemoveLockObserverResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for RemoveLockObserverResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for RemoveLockObserverResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct PhysicalScanLockRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub max_ts: u64,
pub start_key: ::std::vec::Vec<u8>,
pub limit: u32,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a PhysicalScanLockRequest {
fn default() -> &'a PhysicalScanLockRequest {
<PhysicalScanLockRequest as ::protobuf::Message>::default_instance()
}
}
impl PhysicalScanLockRequest {
pub fn new() -> PhysicalScanLockRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_max_ts(&self) -> u64 {
self.max_ts
}
pub fn clear_max_ts(&mut self) {
self.max_ts = 0;
}
pub fn set_max_ts(&mut self, v: u64) {
self.max_ts = v;
}
pub fn get_start_key(&self) -> &[u8] {
&self.start_key
}
pub fn clear_start_key(&mut self) {
self.start_key.clear();
}
pub fn set_start_key(&mut self, v: ::std::vec::Vec<u8>) {
self.start_key = v;
}
pub fn mut_start_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.start_key
}
pub fn take_start_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.start_key, ::std::vec::Vec::new())
}
pub fn get_limit(&self) -> u32 {
self.limit
}
pub fn clear_limit(&mut self) {
self.limit = 0;
}
pub fn set_limit(&mut self, v: u32) {
self.limit = v;
}
}
impl ::protobuf::Message for PhysicalScanLockRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.max_ts = tmp;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.start_key)?;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.limit = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.max_ts != 0 {
my_size += ::protobuf::rt::value_size(2, self.max_ts, ::protobuf::wire_format::WireTypeVarint);
}
if !self.start_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.start_key);
}
if self.limit != 0 {
my_size += ::protobuf::rt::value_size(4, self.limit, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.max_ts != 0 {
os.write_uint64(2, self.max_ts)?;
}
if !self.start_key.is_empty() {
os.write_bytes(3, &self.start_key)?;
}
if self.limit != 0 {
os.write_uint32(4, self.limit)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> PhysicalScanLockRequest {
PhysicalScanLockRequest::new()
}
fn default_instance() -> &'static PhysicalScanLockRequest {
static mut instance: ::protobuf::lazy::Lazy<PhysicalScanLockRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const PhysicalScanLockRequest,
};
unsafe {
instance.get(PhysicalScanLockRequest::new)
}
}
}
impl ::protobuf::Clear for PhysicalScanLockRequest {
fn clear(&mut self) {
self.context.clear();
self.max_ts = 0;
self.start_key.clear();
self.limit = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for PhysicalScanLockRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.max_ts, "max_ts", buf);
::protobuf::PbPrint::fmt(&self.start_key, "start_key", buf);
::protobuf::PbPrint::fmt(&self.limit, "limit", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for PhysicalScanLockRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.max_ts, "max_ts", &mut s);
::protobuf::PbPrint::fmt(&self.start_key, "start_key", &mut s);
::protobuf::PbPrint::fmt(&self.limit, "limit", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for PhysicalScanLockRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct PhysicalScanLockResponse {
pub error: ::std::string::String,
pub locks: ::protobuf::RepeatedField<LockInfo>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a PhysicalScanLockResponse {
fn default() -> &'a PhysicalScanLockResponse {
<PhysicalScanLockResponse as ::protobuf::Message>::default_instance()
}
}
impl PhysicalScanLockResponse {
pub fn new() -> PhysicalScanLockResponse {
::std::default::Default::default()
}
pub fn get_error(&self) -> &str {
&self.error
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn set_error(&mut self, v: ::std::string::String) {
self.error = v;
}
pub fn mut_error(&mut self) -> &mut ::std::string::String {
&mut self.error
}
pub fn take_error(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error, ::std::string::String::new())
}
pub fn get_locks(&self) -> &[LockInfo] {
&self.locks
}
pub fn clear_locks(&mut self) {
self.locks.clear();
}
pub fn set_locks(&mut self, v: ::protobuf::RepeatedField<LockInfo>) {
self.locks = v;
}
pub fn mut_locks(&mut self) -> &mut ::protobuf::RepeatedField<LockInfo> {
&mut self.locks
}
pub fn take_locks(&mut self) -> ::protobuf::RepeatedField<LockInfo> {
::std::mem::replace(&mut self.locks, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for PhysicalScanLockResponse {
fn is_initialized(&self) -> bool {
for v in &self.locks {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.error)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.locks)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.error.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.error);
}
for value in &self.locks {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.error.is_empty() {
os.write_string(1, &self.error)?;
}
for v in &self.locks {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> PhysicalScanLockResponse {
PhysicalScanLockResponse::new()
}
fn default_instance() -> &'static PhysicalScanLockResponse {
static mut instance: ::protobuf::lazy::Lazy<PhysicalScanLockResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const PhysicalScanLockResponse,
};
unsafe {
instance.get(PhysicalScanLockResponse::new)
}
}
}
impl ::protobuf::Clear for PhysicalScanLockResponse {
fn clear(&mut self) {
self.error.clear();
self.locks.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for PhysicalScanLockResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.error, "error", buf);
::protobuf::PbPrint::fmt(&self.locks, "locks", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for PhysicalScanLockResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
::protobuf::PbPrint::fmt(&self.locks, "locks", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for PhysicalScanLockResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SplitRegionRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub split_key: ::std::vec::Vec<u8>,
pub split_keys: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SplitRegionRequest {
fn default() -> &'a SplitRegionRequest {
<SplitRegionRequest as ::protobuf::Message>::default_instance()
}
}
impl SplitRegionRequest {
pub fn new() -> SplitRegionRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_split_key(&self) -> &[u8] {
&self.split_key
}
pub fn clear_split_key(&mut self) {
self.split_key.clear();
}
pub fn set_split_key(&mut self, v: ::std::vec::Vec<u8>) {
self.split_key = v;
}
pub fn mut_split_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.split_key
}
pub fn take_split_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.split_key, ::std::vec::Vec::new())
}
pub fn get_split_keys(&self) -> &[::std::vec::Vec<u8>] {
&self.split_keys
}
pub fn clear_split_keys(&mut self) {
self.split_keys.clear();
}
pub fn set_split_keys(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
self.split_keys = v;
}
pub fn mut_split_keys(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
&mut self.split_keys
}
pub fn take_split_keys(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
::std::mem::replace(&mut self.split_keys, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for SplitRegionRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.split_key)?;
},
3 => {
::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.split_keys)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.split_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.split_key);
}
for value in &self.split_keys {
my_size += ::protobuf::rt::bytes_size(3, &value);
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.split_key.is_empty() {
os.write_bytes(2, &self.split_key)?;
}
for v in &self.split_keys {
os.write_bytes(3, &v)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> SplitRegionRequest {
SplitRegionRequest::new()
}
fn default_instance() -> &'static SplitRegionRequest {
static mut instance: ::protobuf::lazy::Lazy<SplitRegionRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const SplitRegionRequest,
};
unsafe {
instance.get(SplitRegionRequest::new)
}
}
}
impl ::protobuf::Clear for SplitRegionRequest {
fn clear(&mut self) {
self.context.clear();
self.split_key.clear();
self.split_keys.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for SplitRegionRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.split_key, "split_key", buf);
::protobuf::PbPrint::fmt(&self.split_keys, "split_keys", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for SplitRegionRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.split_key, "split_key", &mut s);
::protobuf::PbPrint::fmt(&self.split_keys, "split_keys", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for SplitRegionRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SplitRegionResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub left: ::protobuf::SingularPtrField<super::metapb::Region>,
pub right: ::protobuf::SingularPtrField<super::metapb::Region>,
pub regions: ::protobuf::RepeatedField<super::metapb::Region>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SplitRegionResponse {
fn default() -> &'a SplitRegionResponse {
<SplitRegionResponse as ::protobuf::Message>::default_instance()
}
}
impl SplitRegionResponse {
pub fn new() -> SplitRegionResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_left(&self) -> &super::metapb::Region {
self.left.as_ref().unwrap_or_else(|| super::metapb::Region::default_instance())
}
pub fn clear_left(&mut self) {
self.left.clear();
}
pub fn has_left(&self) -> bool {
self.left.is_some()
}
pub fn set_left(&mut self, v: super::metapb::Region) {
self.left = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_left(&mut self) -> &mut super::metapb::Region {
if self.left.is_none() {
self.left.set_default();
}
self.left.as_mut().unwrap()
}
pub fn take_left(&mut self) -> super::metapb::Region {
self.left.take().unwrap_or_else(|| super::metapb::Region::new())
}
pub fn get_right(&self) -> &super::metapb::Region {
self.right.as_ref().unwrap_or_else(|| super::metapb::Region::default_instance())
}
pub fn clear_right(&mut self) {
self.right.clear();
}
pub fn has_right(&self) -> bool {
self.right.is_some()
}
pub fn set_right(&mut self, v: super::metapb::Region) {
self.right = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_right(&mut self) -> &mut super::metapb::Region {
if self.right.is_none() {
self.right.set_default();
}
self.right.as_mut().unwrap()
}
pub fn take_right(&mut self) -> super::metapb::Region {
self.right.take().unwrap_or_else(|| super::metapb::Region::new())
}
pub fn get_regions(&self) -> &[super::metapb::Region] {
&self.regions
}
pub fn clear_regions(&mut self) {
self.regions.clear();
}
pub fn set_regions(&mut self, v: ::protobuf::RepeatedField<super::metapb::Region>) {
self.regions = v;
}
pub fn mut_regions(&mut self) -> &mut ::protobuf::RepeatedField<super::metapb::Region> {
&mut self.regions
}
pub fn take_regions(&mut self) -> ::protobuf::RepeatedField<super::metapb::Region> {
::std::mem::replace(&mut self.regions, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for SplitRegionResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.left {
if !v.is_initialized() {
return false;
}
};
for v in &self.right {
if !v.is_initialized() {
return false;
}
};
for v in &self.regions {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.left)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.right)?;
},
4 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.regions)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.left.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.right.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.regions {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.left.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.right.as_ref() {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.regions {
os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> SplitRegionResponse {
SplitRegionResponse::new()
}
fn default_instance() -> &'static SplitRegionResponse {
static mut instance: ::protobuf::lazy::Lazy<SplitRegionResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const SplitRegionResponse,
};
unsafe {
instance.get(SplitRegionResponse::new)
}
}
}
impl ::protobuf::Clear for SplitRegionResponse {
fn clear(&mut self) {
self.region_error.clear();
self.left.clear();
self.right.clear();
self.regions.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for SplitRegionResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.left, "left", buf);
::protobuf::PbPrint::fmt(&self.right, "right", buf);
::protobuf::PbPrint::fmt(&self.regions, "regions", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for SplitRegionResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.left, "left", &mut s);
::protobuf::PbPrint::fmt(&self.right, "right", &mut s);
::protobuf::PbPrint::fmt(&self.regions, "regions", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for SplitRegionResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ReadIndexRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub start_ts: u64,
pub ranges: ::protobuf::RepeatedField<KeyRange>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ReadIndexRequest {
fn default() -> &'a ReadIndexRequest {
<ReadIndexRequest as ::protobuf::Message>::default_instance()
}
}
impl ReadIndexRequest {
pub fn new() -> ReadIndexRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_start_ts(&self) -> u64 {
self.start_ts
}
pub fn clear_start_ts(&mut self) {
self.start_ts = 0;
}
pub fn set_start_ts(&mut self, v: u64) {
self.start_ts = v;
}
pub fn get_ranges(&self) -> &[KeyRange] {
&self.ranges
}
pub fn clear_ranges(&mut self) {
self.ranges.clear();
}
pub fn set_ranges(&mut self, v: ::protobuf::RepeatedField<KeyRange>) {
self.ranges = v;
}
pub fn mut_ranges(&mut self) -> &mut ::protobuf::RepeatedField<KeyRange> {
&mut self.ranges
}
pub fn take_ranges(&mut self) -> ::protobuf::RepeatedField<KeyRange> {
::std::mem::replace(&mut self.ranges, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for ReadIndexRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
for v in &self.ranges {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_ts = tmp;
},
3 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.ranges)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.start_ts != 0 {
my_size += ::protobuf::rt::value_size(2, self.start_ts, ::protobuf::wire_format::WireTypeVarint);
}
for value in &self.ranges {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.start_ts != 0 {
os.write_uint64(2, self.start_ts)?;
}
for v in &self.ranges {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ReadIndexRequest {
ReadIndexRequest::new()
}
fn default_instance() -> &'static ReadIndexRequest {
static mut instance: ::protobuf::lazy::Lazy<ReadIndexRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ReadIndexRequest,
};
unsafe {
instance.get(ReadIndexRequest::new)
}
}
}
impl ::protobuf::Clear for ReadIndexRequest {
fn clear(&mut self) {
self.context.clear();
self.start_ts = 0;
self.ranges.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for ReadIndexRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.start_ts, "start_ts", buf);
::protobuf::PbPrint::fmt(&self.ranges, "ranges", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for ReadIndexRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.start_ts, "start_ts", &mut s);
::protobuf::PbPrint::fmt(&self.ranges, "ranges", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for ReadIndexRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ReadIndexResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub read_index: u64,
pub locked: ::protobuf::SingularPtrField<LockInfo>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ReadIndexResponse {
fn default() -> &'a ReadIndexResponse {
<ReadIndexResponse as ::protobuf::Message>::default_instance()
}
}
impl ReadIndexResponse {
pub fn new() -> ReadIndexResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_read_index(&self) -> u64 {
self.read_index
}
pub fn clear_read_index(&mut self) {
self.read_index = 0;
}
pub fn set_read_index(&mut self, v: u64) {
self.read_index = v;
}
pub fn get_locked(&self) -> &LockInfo {
self.locked.as_ref().unwrap_or_else(|| LockInfo::default_instance())
}
pub fn clear_locked(&mut self) {
self.locked.clear();
}
pub fn has_locked(&self) -> bool {
self.locked.is_some()
}
pub fn set_locked(&mut self, v: LockInfo) {
self.locked = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_locked(&mut self) -> &mut LockInfo {
if self.locked.is_none() {
self.locked.set_default();
}
self.locked.as_mut().unwrap()
}
pub fn take_locked(&mut self) -> LockInfo {
self.locked.take().unwrap_or_else(|| LockInfo::new())
}
}
impl ::protobuf::Message for ReadIndexResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.locked {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.read_index = tmp;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.locked)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.read_index != 0 {
my_size += ::protobuf::rt::value_size(2, self.read_index, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.locked.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.read_index != 0 {
os.write_uint64(2, self.read_index)?;
}
if let Some(ref v) = self.locked.as_ref() {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ReadIndexResponse {
ReadIndexResponse::new()
}
fn default_instance() -> &'static ReadIndexResponse {
static mut instance: ::protobuf::lazy::Lazy<ReadIndexResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ReadIndexResponse,
};
unsafe {
instance.get(ReadIndexResponse::new)
}
}
}
impl ::protobuf::Clear for ReadIndexResponse {
fn clear(&mut self) {
self.region_error.clear();
self.read_index = 0;
self.locked.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for ReadIndexResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.read_index, "read_index", buf);
::protobuf::PbPrint::fmt(&self.locked, "locked", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for ReadIndexResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.read_index, "read_index", &mut s);
::protobuf::PbPrint::fmt(&self.locked, "locked", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for ReadIndexResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct VerMutation {
pub op: VerOp,
pub key: ::std::vec::Vec<u8>,
pub value: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a VerMutation {
fn default() -> &'a VerMutation {
<VerMutation as ::protobuf::Message>::default_instance()
}
}
impl VerMutation {
pub fn new() -> VerMutation {
::std::default::Default::default()
}
pub fn get_op(&self) -> VerOp {
self.op
}
pub fn clear_op(&mut self) {
self.op = VerOp::VerPut;
}
pub fn set_op(&mut self, v: VerOp) {
self.op = v;
}
pub fn get_key(&self) -> &[u8] {
&self.key
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
self.key = v;
}
pub fn mut_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.key
}
pub fn take_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.key, ::std::vec::Vec::new())
}
pub fn get_value(&self) -> &[u8] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::std::vec::Vec<u8>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.value
}
pub fn take_value(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.value, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for VerMutation {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type == ::protobuf::wire_format::WireTypeVarint {self.op = is.read_enum()?;} else {return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));}
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.op != VerOp::VerPut {
my_size += ::protobuf::rt::enum_size(1, self.op);
}
if !self.key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.key);
}
if !self.value.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.value);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.op != VerOp::VerPut {
os.write_enum(1, self.op.value())?;
}
if !self.key.is_empty() {
os.write_bytes(2, &self.key)?;
}
if !self.value.is_empty() {
os.write_bytes(3, &self.value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> VerMutation {
VerMutation::new()
}
fn default_instance() -> &'static VerMutation {
static mut instance: ::protobuf::lazy::Lazy<VerMutation> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const VerMutation,
};
unsafe {
instance.get(VerMutation::new)
}
}
}
impl ::protobuf::Clear for VerMutation {
fn clear(&mut self) {
self.op = VerOp::VerPut;
self.key.clear();
self.value.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for VerMutation {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.op, "op", buf);
::protobuf::PbPrint::fmt(&self.key, "key", buf);
::protobuf::PbPrint::fmt(&self.value, "value", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for VerMutation {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.op, "op", &mut s);
::protobuf::PbPrint::fmt(&self.key, "key", &mut s);
::protobuf::PbPrint::fmt(&self.value, "value", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for VerMutation {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct VerValue {
pub value: ::std::vec::Vec<u8>,
pub version: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a VerValue {
fn default() -> &'a VerValue {
<VerValue as ::protobuf::Message>::default_instance()
}
}
impl VerValue {
pub fn new() -> VerValue {
::std::default::Default::default()
}
pub fn get_value(&self) -> &[u8] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::std::vec::Vec<u8>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.value
}
pub fn take_value(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.value, ::std::vec::Vec::new())
}
pub fn get_version(&self) -> u64 {
self.version
}
pub fn clear_version(&mut self) {
self.version = 0;
}
pub fn set_version(&mut self, v: u64) {
self.version = v;
}
}
impl ::protobuf::Message for VerValue {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.version = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.value.is_empty() {
my_size += ::protobuf::rt::bytes_size(1, &self.value);
}
if self.version != 0 {
my_size += ::protobuf::rt::value_size(2, self.version, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.value.is_empty() {
os.write_bytes(1, &self.value)?;
}
if self.version != 0 {
os.write_uint64(2, self.version)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> VerValue {
VerValue::new()
}
fn default_instance() -> &'static VerValue {
static mut instance: ::protobuf::lazy::Lazy<VerValue> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const VerValue,
};
unsafe {
instance.get(VerValue::new)
}
}
}
impl ::protobuf::Clear for VerValue {
fn clear(&mut self) {
self.value.clear();
self.version = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for VerValue {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.value, "value", buf);
::protobuf::PbPrint::fmt(&self.version, "version", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for VerValue {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.value, "value", &mut s);
::protobuf::PbPrint::fmt(&self.version, "version", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for VerValue {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct VerError {
pub error: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a VerError {
fn default() -> &'a VerError {
<VerError as ::protobuf::Message>::default_instance()
}
}
impl VerError {
pub fn new() -> VerError {
::std::default::Default::default()
}
pub fn get_error(&self) -> &str {
&self.error
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn set_error(&mut self, v: ::std::string::String) {
self.error = v;
}
pub fn mut_error(&mut self) -> &mut ::std::string::String {
&mut self.error
}
pub fn take_error(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error, ::std::string::String::new())
}
}
impl ::protobuf::Message for VerError {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.error.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.error);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.error.is_empty() {
os.write_string(1, &self.error)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> VerError {
VerError::new()
}
fn default_instance() -> &'static VerError {
static mut instance: ::protobuf::lazy::Lazy<VerError> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const VerError,
};
unsafe {
instance.get(VerError::new)
}
}
}
impl ::protobuf::Clear for VerError {
fn clear(&mut self) {
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for VerError {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for VerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for VerError {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct VerKvPair {
pub error: ::protobuf::SingularPtrField<VerError>,
pub key: ::std::vec::Vec<u8>,
pub value: ::protobuf::SingularPtrField<VerValue>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a VerKvPair {
fn default() -> &'a VerKvPair {
<VerKvPair as ::protobuf::Message>::default_instance()
}
}
impl VerKvPair {
pub fn new() -> VerKvPair {
::std::default::Default::default()
}
pub fn get_error(&self) -> &VerError {
self.error.as_ref().unwrap_or_else(|| VerError::default_instance())
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn has_error(&self) -> bool {
self.error.is_some()
}
pub fn set_error(&mut self, v: VerError) {
self.error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_error(&mut self) -> &mut VerError {
if self.error.is_none() {
self.error.set_default();
}
self.error.as_mut().unwrap()
}
pub fn take_error(&mut self) -> VerError {
self.error.take().unwrap_or_else(|| VerError::new())
}
pub fn get_key(&self) -> &[u8] {
&self.key
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
self.key = v;
}
pub fn mut_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.key
}
pub fn take_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.key, ::std::vec::Vec::new())
}
pub fn get_value(&self) -> &VerValue {
self.value.as_ref().unwrap_or_else(|| VerValue::default_instance())
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn has_value(&self) -> bool {
self.value.is_some()
}
pub fn set_value(&mut self, v: VerValue) {
self.value = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_value(&mut self) -> &mut VerValue {
if self.value.is_none() {
self.value.set_default();
}
self.value.as_mut().unwrap()
}
pub fn take_value(&mut self) -> VerValue {
self.value.take().unwrap_or_else(|| VerValue::new())
}
}
impl ::protobuf::Message for VerKvPair {
fn is_initialized(&self) -> bool {
for v in &self.error {
if !v.is_initialized() {
return false;
}
};
for v in &self.value {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.error)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.value)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.key);
}
if let Some(ref v) = self.value.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.key.is_empty() {
os.write_bytes(2, &self.key)?;
}
if let Some(ref v) = self.value.as_ref() {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> VerKvPair {
VerKvPair::new()
}
fn default_instance() -> &'static VerKvPair {
static mut instance: ::protobuf::lazy::Lazy<VerKvPair> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const VerKvPair,
};
unsafe {
instance.get(VerKvPair::new)
}
}
}
impl ::protobuf::Clear for VerKvPair {
fn clear(&mut self) {
self.error.clear();
self.key.clear();
self.value.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for VerKvPair {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.error, "error", buf);
::protobuf::PbPrint::fmt(&self.key, "key", buf);
::protobuf::PbPrint::fmt(&self.value, "value", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for VerKvPair {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
::protobuf::PbPrint::fmt(&self.key, "key", &mut s);
::protobuf::PbPrint::fmt(&self.value, "value", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for VerKvPair {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct VerGetRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub key: ::std::vec::Vec<u8>,
pub start_version: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a VerGetRequest {
fn default() -> &'a VerGetRequest {
<VerGetRequest as ::protobuf::Message>::default_instance()
}
}
impl VerGetRequest {
pub fn new() -> VerGetRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_key(&self) -> &[u8] {
&self.key
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
self.key = v;
}
pub fn mut_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.key
}
pub fn take_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.key, ::std::vec::Vec::new())
}
pub fn get_start_version(&self) -> u64 {
self.start_version
}
pub fn clear_start_version(&mut self) {
self.start_version = 0;
}
pub fn set_start_version(&mut self, v: u64) {
self.start_version = v;
}
}
impl ::protobuf::Message for VerGetRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_version = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.key);
}
if self.start_version != 0 {
my_size += ::protobuf::rt::value_size(3, self.start_version, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.key.is_empty() {
os.write_bytes(2, &self.key)?;
}
if self.start_version != 0 {
os.write_uint64(3, self.start_version)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> VerGetRequest {
VerGetRequest::new()
}
fn default_instance() -> &'static VerGetRequest {
static mut instance: ::protobuf::lazy::Lazy<VerGetRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const VerGetRequest,
};
unsafe {
instance.get(VerGetRequest::new)
}
}
}
impl ::protobuf::Clear for VerGetRequest {
fn clear(&mut self) {
self.context.clear();
self.key.clear();
self.start_version = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for VerGetRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.key, "key", buf);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for VerGetRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.key, "key", &mut s);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for VerGetRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct VerGetResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::protobuf::SingularPtrField<VerError>,
pub value: ::protobuf::SingularPtrField<VerValue>,
pub not_found: bool,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a VerGetResponse {
fn default() -> &'a VerGetResponse {
<VerGetResponse as ::protobuf::Message>::default_instance()
}
}
impl VerGetResponse {
pub fn new() -> VerGetResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &VerError {
self.error.as_ref().unwrap_or_else(|| VerError::default_instance())
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn has_error(&self) -> bool {
self.error.is_some()
}
pub fn set_error(&mut self, v: VerError) {
self.error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_error(&mut self) -> &mut VerError {
if self.error.is_none() {
self.error.set_default();
}
self.error.as_mut().unwrap()
}
pub fn take_error(&mut self) -> VerError {
self.error.take().unwrap_or_else(|| VerError::new())
}
pub fn get_value(&self) -> &VerValue {
self.value.as_ref().unwrap_or_else(|| VerValue::default_instance())
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn has_value(&self) -> bool {
self.value.is_some()
}
pub fn set_value(&mut self, v: VerValue) {
self.value = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_value(&mut self) -> &mut VerValue {
if self.value.is_none() {
self.value.set_default();
}
self.value.as_mut().unwrap()
}
pub fn take_value(&mut self) -> VerValue {
self.value.take().unwrap_or_else(|| VerValue::new())
}
pub fn get_not_found(&self) -> bool {
self.not_found
}
pub fn clear_not_found(&mut self) {
self.not_found = false;
}
pub fn set_not_found(&mut self, v: bool) {
self.not_found = v;
}
}
impl ::protobuf::Message for VerGetResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.error {
if !v.is_initialized() {
return false;
}
};
for v in &self.value {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.error)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.value)?;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.not_found = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.value.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.not_found != false {
my_size += 2;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.error.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.value.as_ref() {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.not_found != false {
os.write_bool(4, self.not_found)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> VerGetResponse {
VerGetResponse::new()
}
fn default_instance() -> &'static VerGetResponse {
static mut instance: ::protobuf::lazy::Lazy<VerGetResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const VerGetResponse,
};
unsafe {
instance.get(VerGetResponse::new)
}
}
}
impl ::protobuf::Clear for VerGetResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.value.clear();
self.not_found = false;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for VerGetResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
::protobuf::PbPrint::fmt(&self.value, "value", buf);
::protobuf::PbPrint::fmt(&self.not_found, "not_found", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for VerGetResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
::protobuf::PbPrint::fmt(&self.value, "value", &mut s);
::protobuf::PbPrint::fmt(&self.not_found, "not_found", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for VerGetResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct VerBatchGetRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub key: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
pub start_version: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a VerBatchGetRequest {
fn default() -> &'a VerBatchGetRequest {
<VerBatchGetRequest as ::protobuf::Message>::default_instance()
}
}
impl VerBatchGetRequest {
pub fn new() -> VerBatchGetRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_key(&self) -> &[::std::vec::Vec<u8>] {
&self.key
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn set_key(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
self.key = v;
}
pub fn mut_key(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
&mut self.key
}
pub fn take_key(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
::std::mem::replace(&mut self.key, ::protobuf::RepeatedField::new())
}
pub fn get_start_version(&self) -> u64 {
self.start_version
}
pub fn clear_start_version(&mut self) {
self.start_version = 0;
}
pub fn set_start_version(&mut self, v: u64) {
self.start_version = v;
}
}
impl ::protobuf::Message for VerBatchGetRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.key)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_version = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.key {
my_size += ::protobuf::rt::bytes_size(2, &value);
};
if self.start_version != 0 {
my_size += ::protobuf::rt::value_size(3, self.start_version, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.key {
os.write_bytes(2, &v)?;
};
if self.start_version != 0 {
os.write_uint64(3, self.start_version)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> VerBatchGetRequest {
VerBatchGetRequest::new()
}
fn default_instance() -> &'static VerBatchGetRequest {
static mut instance: ::protobuf::lazy::Lazy<VerBatchGetRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const VerBatchGetRequest,
};
unsafe {
instance.get(VerBatchGetRequest::new)
}
}
}
impl ::protobuf::Clear for VerBatchGetRequest {
fn clear(&mut self) {
self.context.clear();
self.key.clear();
self.start_version = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for VerBatchGetRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.key, "key", buf);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for VerBatchGetRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.key, "key", &mut s);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for VerBatchGetRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct VerBatchGetResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub pairs: ::protobuf::RepeatedField<VerKvPair>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a VerBatchGetResponse {
fn default() -> &'a VerBatchGetResponse {
<VerBatchGetResponse as ::protobuf::Message>::default_instance()
}
}
impl VerBatchGetResponse {
pub fn new() -> VerBatchGetResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_pairs(&self) -> &[VerKvPair] {
&self.pairs
}
pub fn clear_pairs(&mut self) {
self.pairs.clear();
}
pub fn set_pairs(&mut self, v: ::protobuf::RepeatedField<VerKvPair>) {
self.pairs = v;
}
pub fn mut_pairs(&mut self) -> &mut ::protobuf::RepeatedField<VerKvPair> {
&mut self.pairs
}
pub fn take_pairs(&mut self) -> ::protobuf::RepeatedField<VerKvPair> {
::std::mem::replace(&mut self.pairs, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for VerBatchGetResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.pairs {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.pairs)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.pairs {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.pairs {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> VerBatchGetResponse {
VerBatchGetResponse::new()
}
fn default_instance() -> &'static VerBatchGetResponse {
static mut instance: ::protobuf::lazy::Lazy<VerBatchGetResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const VerBatchGetResponse,
};
unsafe {
instance.get(VerBatchGetResponse::new)
}
}
}
impl ::protobuf::Clear for VerBatchGetResponse {
fn clear(&mut self) {
self.region_error.clear();
self.pairs.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for VerBatchGetResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.pairs, "pairs", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for VerBatchGetResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.pairs, "pairs", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for VerBatchGetResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct VerMutRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub r_mut: ::protobuf::SingularPtrField<VerMutation>,
pub version: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a VerMutRequest {
fn default() -> &'a VerMutRequest {
<VerMutRequest as ::protobuf::Message>::default_instance()
}
}
impl VerMutRequest {
pub fn new() -> VerMutRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_mut(&self) -> &VerMutation {
self.r_mut.as_ref().unwrap_or_else(|| VerMutation::default_instance())
}
pub fn clear_mut(&mut self) {
self.r_mut.clear();
}
pub fn has_mut(&self) -> bool {
self.r_mut.is_some()
}
pub fn set_mut(&mut self, v: VerMutation) {
self.r_mut = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_mut(&mut self) -> &mut VerMutation {
if self.r_mut.is_none() {
self.r_mut.set_default();
}
self.r_mut.as_mut().unwrap()
}
pub fn take_mut(&mut self) -> VerMutation {
self.r_mut.take().unwrap_or_else(|| VerMutation::new())
}
pub fn get_version(&self) -> u64 {
self.version
}
pub fn clear_version(&mut self) {
self.version = 0;
}
pub fn set_version(&mut self, v: u64) {
self.version = v;
}
}
impl ::protobuf::Message for VerMutRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
for v in &self.r_mut {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.r_mut)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.version = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.r_mut.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.version != 0 {
my_size += ::protobuf::rt::value_size(3, self.version, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.r_mut.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.version != 0 {
os.write_uint64(3, self.version)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> VerMutRequest {
VerMutRequest::new()
}
fn default_instance() -> &'static VerMutRequest {
static mut instance: ::protobuf::lazy::Lazy<VerMutRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const VerMutRequest,
};
unsafe {
instance.get(VerMutRequest::new)
}
}
}
impl ::protobuf::Clear for VerMutRequest {
fn clear(&mut self) {
self.context.clear();
self.r_mut.clear();
self.version = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for VerMutRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.r_mut, "r_mut", buf);
::protobuf::PbPrint::fmt(&self.version, "version", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for VerMutRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.r_mut, "r_mut", &mut s);
::protobuf::PbPrint::fmt(&self.version, "version", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for VerMutRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct VerMutResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::protobuf::SingularPtrField<VerError>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a VerMutResponse {
fn default() -> &'a VerMutResponse {
<VerMutResponse as ::protobuf::Message>::default_instance()
}
}
impl VerMutResponse {
pub fn new() -> VerMutResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &VerError {
self.error.as_ref().unwrap_or_else(|| VerError::default_instance())
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn has_error(&self) -> bool {
self.error.is_some()
}
pub fn set_error(&mut self, v: VerError) {
self.error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_error(&mut self) -> &mut VerError {
if self.error.is_none() {
self.error.set_default();
}
self.error.as_mut().unwrap()
}
pub fn take_error(&mut self) -> VerError {
self.error.take().unwrap_or_else(|| VerError::new())
}
}
impl ::protobuf::Message for VerMutResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.error.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> VerMutResponse {
VerMutResponse::new()
}
fn default_instance() -> &'static VerMutResponse {
static mut instance: ::protobuf::lazy::Lazy<VerMutResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const VerMutResponse,
};
unsafe {
instance.get(VerMutResponse::new)
}
}
}
impl ::protobuf::Clear for VerMutResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for VerMutResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for VerMutResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for VerMutResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct VerBatchMutRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub muts: ::protobuf::RepeatedField<VerMutation>,
pub version: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a VerBatchMutRequest {
fn default() -> &'a VerBatchMutRequest {
<VerBatchMutRequest as ::protobuf::Message>::default_instance()
}
}
impl VerBatchMutRequest {
pub fn new() -> VerBatchMutRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_muts(&self) -> &[VerMutation] {
&self.muts
}
pub fn clear_muts(&mut self) {
self.muts.clear();
}
pub fn set_muts(&mut self, v: ::protobuf::RepeatedField<VerMutation>) {
self.muts = v;
}
pub fn mut_muts(&mut self) -> &mut ::protobuf::RepeatedField<VerMutation> {
&mut self.muts
}
pub fn take_muts(&mut self) -> ::protobuf::RepeatedField<VerMutation> {
::std::mem::replace(&mut self.muts, ::protobuf::RepeatedField::new())
}
pub fn get_version(&self) -> u64 {
self.version
}
pub fn clear_version(&mut self) {
self.version = 0;
}
pub fn set_version(&mut self, v: u64) {
self.version = v;
}
}
impl ::protobuf::Message for VerBatchMutRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
for v in &self.muts {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.muts)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.version = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.muts {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if self.version != 0 {
my_size += ::protobuf::rt::value_size(3, self.version, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.muts {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
if self.version != 0 {
os.write_uint64(3, self.version)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> VerBatchMutRequest {
VerBatchMutRequest::new()
}
fn default_instance() -> &'static VerBatchMutRequest {
static mut instance: ::protobuf::lazy::Lazy<VerBatchMutRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const VerBatchMutRequest,
};
unsafe {
instance.get(VerBatchMutRequest::new)
}
}
}
impl ::protobuf::Clear for VerBatchMutRequest {
fn clear(&mut self) {
self.context.clear();
self.muts.clear();
self.version = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for VerBatchMutRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.muts, "muts", buf);
::protobuf::PbPrint::fmt(&self.version, "version", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for VerBatchMutRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.muts, "muts", &mut s);
::protobuf::PbPrint::fmt(&self.version, "version", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for VerBatchMutRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct VerBatchMutResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::protobuf::SingularPtrField<VerError>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a VerBatchMutResponse {
fn default() -> &'a VerBatchMutResponse {
<VerBatchMutResponse as ::protobuf::Message>::default_instance()
}
}
impl VerBatchMutResponse {
pub fn new() -> VerBatchMutResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &VerError {
self.error.as_ref().unwrap_or_else(|| VerError::default_instance())
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn has_error(&self) -> bool {
self.error.is_some()
}
pub fn set_error(&mut self, v: VerError) {
self.error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_error(&mut self) -> &mut VerError {
if self.error.is_none() {
self.error.set_default();
}
self.error.as_mut().unwrap()
}
pub fn take_error(&mut self) -> VerError {
self.error.take().unwrap_or_else(|| VerError::new())
}
}
impl ::protobuf::Message for VerBatchMutResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.error.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> VerBatchMutResponse {
VerBatchMutResponse::new()
}
fn default_instance() -> &'static VerBatchMutResponse {
static mut instance: ::protobuf::lazy::Lazy<VerBatchMutResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const VerBatchMutResponse,
};
unsafe {
instance.get(VerBatchMutResponse::new)
}
}
}
impl ::protobuf::Clear for VerBatchMutResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for VerBatchMutResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for VerBatchMutResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for VerBatchMutResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct VerScanRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub start_key: ::std::vec::Vec<u8>,
pub end_key: ::std::vec::Vec<u8>,
pub limit: u32,
pub key_only: bool,
pub reverse: bool,
pub start_version: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a VerScanRequest {
fn default() -> &'a VerScanRequest {
<VerScanRequest as ::protobuf::Message>::default_instance()
}
}
impl VerScanRequest {
pub fn new() -> VerScanRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_start_key(&self) -> &[u8] {
&self.start_key
}
pub fn clear_start_key(&mut self) {
self.start_key.clear();
}
pub fn set_start_key(&mut self, v: ::std::vec::Vec<u8>) {
self.start_key = v;
}
pub fn mut_start_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.start_key
}
pub fn take_start_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.start_key, ::std::vec::Vec::new())
}
pub fn get_end_key(&self) -> &[u8] {
&self.end_key
}
pub fn clear_end_key(&mut self) {
self.end_key.clear();
}
pub fn set_end_key(&mut self, v: ::std::vec::Vec<u8>) {
self.end_key = v;
}
pub fn mut_end_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.end_key
}
pub fn take_end_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.end_key, ::std::vec::Vec::new())
}
pub fn get_limit(&self) -> u32 {
self.limit
}
pub fn clear_limit(&mut self) {
self.limit = 0;
}
pub fn set_limit(&mut self, v: u32) {
self.limit = v;
}
pub fn get_key_only(&self) -> bool {
self.key_only
}
pub fn clear_key_only(&mut self) {
self.key_only = false;
}
pub fn set_key_only(&mut self, v: bool) {
self.key_only = v;
}
pub fn get_reverse(&self) -> bool {
self.reverse
}
pub fn clear_reverse(&mut self) {
self.reverse = false;
}
pub fn set_reverse(&mut self, v: bool) {
self.reverse = v;
}
pub fn get_start_version(&self) -> u64 {
self.start_version
}
pub fn clear_start_version(&mut self) {
self.start_version = 0;
}
pub fn set_start_version(&mut self, v: u64) {
self.start_version = v;
}
}
impl ::protobuf::Message for VerScanRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.start_key)?;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.end_key)?;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.limit = tmp;
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.key_only = tmp;
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.reverse = tmp;
},
7 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_version = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.start_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.start_key);
}
if !self.end_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.end_key);
}
if self.limit != 0 {
my_size += ::protobuf::rt::value_size(4, self.limit, ::protobuf::wire_format::WireTypeVarint);
}
if self.key_only != false {
my_size += 2;
}
if self.reverse != false {
my_size += 2;
}
if self.start_version != 0 {
my_size += ::protobuf::rt::value_size(7, self.start_version, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.start_key.is_empty() {
os.write_bytes(2, &self.start_key)?;
}
if !self.end_key.is_empty() {
os.write_bytes(3, &self.end_key)?;
}
if self.limit != 0 {
os.write_uint32(4, self.limit)?;
}
if self.key_only != false {
os.write_bool(5, self.key_only)?;
}
if self.reverse != false {
os.write_bool(6, self.reverse)?;
}
if self.start_version != 0 {
os.write_uint64(7, self.start_version)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> VerScanRequest {
VerScanRequest::new()
}
fn default_instance() -> &'static VerScanRequest {
static mut instance: ::protobuf::lazy::Lazy<VerScanRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const VerScanRequest,
};
unsafe {
instance.get(VerScanRequest::new)
}
}
}
impl ::protobuf::Clear for VerScanRequest {
fn clear(&mut self) {
self.context.clear();
self.start_key.clear();
self.end_key.clear();
self.limit = 0;
self.key_only = false;
self.reverse = false;
self.start_version = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for VerScanRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.start_key, "start_key", buf);
::protobuf::PbPrint::fmt(&self.end_key, "end_key", buf);
::protobuf::PbPrint::fmt(&self.limit, "limit", buf);
::protobuf::PbPrint::fmt(&self.key_only, "key_only", buf);
::protobuf::PbPrint::fmt(&self.reverse, "reverse", buf);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for VerScanRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.start_key, "start_key", &mut s);
::protobuf::PbPrint::fmt(&self.end_key, "end_key", &mut s);
::protobuf::PbPrint::fmt(&self.limit, "limit", &mut s);
::protobuf::PbPrint::fmt(&self.key_only, "key_only", &mut s);
::protobuf::PbPrint::fmt(&self.reverse, "reverse", &mut s);
::protobuf::PbPrint::fmt(&self.start_version, "start_version", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for VerScanRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct VerScanResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub pairs: ::protobuf::RepeatedField<VerKvPair>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a VerScanResponse {
fn default() -> &'a VerScanResponse {
<VerScanResponse as ::protobuf::Message>::default_instance()
}
}
impl VerScanResponse {
pub fn new() -> VerScanResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_pairs(&self) -> &[VerKvPair] {
&self.pairs
}
pub fn clear_pairs(&mut self) {
self.pairs.clear();
}
pub fn set_pairs(&mut self, v: ::protobuf::RepeatedField<VerKvPair>) {
self.pairs = v;
}
pub fn mut_pairs(&mut self) -> &mut ::protobuf::RepeatedField<VerKvPair> {
&mut self.pairs
}
pub fn take_pairs(&mut self) -> ::protobuf::RepeatedField<VerKvPair> {
::std::mem::replace(&mut self.pairs, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for VerScanResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.pairs {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.pairs)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.pairs {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.pairs {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> VerScanResponse {
VerScanResponse::new()
}
fn default_instance() -> &'static VerScanResponse {
static mut instance: ::protobuf::lazy::Lazy<VerScanResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const VerScanResponse,
};
unsafe {
instance.get(VerScanResponse::new)
}
}
}
impl ::protobuf::Clear for VerScanResponse {
fn clear(&mut self) {
self.region_error.clear();
self.pairs.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for VerScanResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.pairs, "pairs", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for VerScanResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.pairs, "pairs", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for VerScanResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct VerDeleteRangeRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub start_key: ::std::vec::Vec<u8>,
pub end_key: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a VerDeleteRangeRequest {
fn default() -> &'a VerDeleteRangeRequest {
<VerDeleteRangeRequest as ::protobuf::Message>::default_instance()
}
}
impl VerDeleteRangeRequest {
pub fn new() -> VerDeleteRangeRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_start_key(&self) -> &[u8] {
&self.start_key
}
pub fn clear_start_key(&mut self) {
self.start_key.clear();
}
pub fn set_start_key(&mut self, v: ::std::vec::Vec<u8>) {
self.start_key = v;
}
pub fn mut_start_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.start_key
}
pub fn take_start_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.start_key, ::std::vec::Vec::new())
}
pub fn get_end_key(&self) -> &[u8] {
&self.end_key
}
pub fn clear_end_key(&mut self) {
self.end_key.clear();
}
pub fn set_end_key(&mut self, v: ::std::vec::Vec<u8>) {
self.end_key = v;
}
pub fn mut_end_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.end_key
}
pub fn take_end_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.end_key, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for VerDeleteRangeRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.start_key)?;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.end_key)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.start_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.start_key);
}
if !self.end_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.end_key);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.start_key.is_empty() {
os.write_bytes(2, &self.start_key)?;
}
if !self.end_key.is_empty() {
os.write_bytes(3, &self.end_key)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> VerDeleteRangeRequest {
VerDeleteRangeRequest::new()
}
fn default_instance() -> &'static VerDeleteRangeRequest {
static mut instance: ::protobuf::lazy::Lazy<VerDeleteRangeRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const VerDeleteRangeRequest,
};
unsafe {
instance.get(VerDeleteRangeRequest::new)
}
}
}
impl ::protobuf::Clear for VerDeleteRangeRequest {
fn clear(&mut self) {
self.context.clear();
self.start_key.clear();
self.end_key.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for VerDeleteRangeRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.start_key, "start_key", buf);
::protobuf::PbPrint::fmt(&self.end_key, "end_key", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for VerDeleteRangeRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.start_key, "start_key", &mut s);
::protobuf::PbPrint::fmt(&self.end_key, "end_key", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for VerDeleteRangeRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct VerDeleteRangeResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::protobuf::SingularPtrField<VerError>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a VerDeleteRangeResponse {
fn default() -> &'a VerDeleteRangeResponse {
<VerDeleteRangeResponse as ::protobuf::Message>::default_instance()
}
}
impl VerDeleteRangeResponse {
pub fn new() -> VerDeleteRangeResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &VerError {
self.error.as_ref().unwrap_or_else(|| VerError::default_instance())
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn has_error(&self) -> bool {
self.error.is_some()
}
pub fn set_error(&mut self, v: VerError) {
self.error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_error(&mut self) -> &mut VerError {
if self.error.is_none() {
self.error.set_default();
}
self.error.as_mut().unwrap()
}
pub fn take_error(&mut self) -> VerError {
self.error.take().unwrap_or_else(|| VerError::new())
}
}
impl ::protobuf::Message for VerDeleteRangeResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.error)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.error.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> VerDeleteRangeResponse {
VerDeleteRangeResponse::new()
}
fn default_instance() -> &'static VerDeleteRangeResponse {
static mut instance: ::protobuf::lazy::Lazy<VerDeleteRangeResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const VerDeleteRangeResponse,
};
unsafe {
instance.get(VerDeleteRangeResponse::new)
}
}
}
impl ::protobuf::Clear for VerDeleteRangeResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for VerDeleteRangeResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for VerDeleteRangeResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for VerDeleteRangeResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct MvccGetByKeyRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub key: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MvccGetByKeyRequest {
fn default() -> &'a MvccGetByKeyRequest {
<MvccGetByKeyRequest as ::protobuf::Message>::default_instance()
}
}
impl MvccGetByKeyRequest {
pub fn new() -> MvccGetByKeyRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_key(&self) -> &[u8] {
&self.key
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
self.key = v;
}
pub fn mut_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.key
}
pub fn take_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.key, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for MvccGetByKeyRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.key);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.key.is_empty() {
os.write_bytes(2, &self.key)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> MvccGetByKeyRequest {
MvccGetByKeyRequest::new()
}
fn default_instance() -> &'static MvccGetByKeyRequest {
static mut instance: ::protobuf::lazy::Lazy<MvccGetByKeyRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const MvccGetByKeyRequest,
};
unsafe {
instance.get(MvccGetByKeyRequest::new)
}
}
}
impl ::protobuf::Clear for MvccGetByKeyRequest {
fn clear(&mut self) {
self.context.clear();
self.key.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for MvccGetByKeyRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.key, "key", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for MvccGetByKeyRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.key, "key", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for MvccGetByKeyRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct MvccGetByKeyResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::std::string::String,
pub info: ::protobuf::SingularPtrField<MvccInfo>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MvccGetByKeyResponse {
fn default() -> &'a MvccGetByKeyResponse {
<MvccGetByKeyResponse as ::protobuf::Message>::default_instance()
}
}
impl MvccGetByKeyResponse {
pub fn new() -> MvccGetByKeyResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &str {
&self.error
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn set_error(&mut self, v: ::std::string::String) {
self.error = v;
}
pub fn mut_error(&mut self) -> &mut ::std::string::String {
&mut self.error
}
pub fn take_error(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error, ::std::string::String::new())
}
pub fn get_info(&self) -> &MvccInfo {
self.info.as_ref().unwrap_or_else(|| MvccInfo::default_instance())
}
pub fn clear_info(&mut self) {
self.info.clear();
}
pub fn has_info(&self) -> bool {
self.info.is_some()
}
pub fn set_info(&mut self, v: MvccInfo) {
self.info = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_info(&mut self) -> &mut MvccInfo {
if self.info.is_none() {
self.info.set_default();
}
self.info.as_mut().unwrap()
}
pub fn take_info(&mut self) -> MvccInfo {
self.info.take().unwrap_or_else(|| MvccInfo::new())
}
}
impl ::protobuf::Message for MvccGetByKeyResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.info {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.error)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.info)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.error.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.error);
}
if let Some(ref v) = self.info.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.error.is_empty() {
os.write_string(2, &self.error)?;
}
if let Some(ref v) = self.info.as_ref() {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> MvccGetByKeyResponse {
MvccGetByKeyResponse::new()
}
fn default_instance() -> &'static MvccGetByKeyResponse {
static mut instance: ::protobuf::lazy::Lazy<MvccGetByKeyResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const MvccGetByKeyResponse,
};
unsafe {
instance.get(MvccGetByKeyResponse::new)
}
}
}
impl ::protobuf::Clear for MvccGetByKeyResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.info.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for MvccGetByKeyResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
::protobuf::PbPrint::fmt(&self.info, "info", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for MvccGetByKeyResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
::protobuf::PbPrint::fmt(&self.info, "info", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for MvccGetByKeyResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct MvccGetByStartTsRequest {
pub context: ::protobuf::SingularPtrField<Context>,
pub start_ts: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MvccGetByStartTsRequest {
fn default() -> &'a MvccGetByStartTsRequest {
<MvccGetByStartTsRequest as ::protobuf::Message>::default_instance()
}
}
impl MvccGetByStartTsRequest {
pub fn new() -> MvccGetByStartTsRequest {
::std::default::Default::default()
}
pub fn get_context(&self) -> &Context {
self.context.as_ref().unwrap_or_else(|| Context::default_instance())
}
pub fn clear_context(&mut self) {
self.context.clear();
}
pub fn has_context(&self) -> bool {
self.context.is_some()
}
pub fn set_context(&mut self, v: Context) {
self.context = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_context(&mut self) -> &mut Context {
if self.context.is_none() {
self.context.set_default();
}
self.context.as_mut().unwrap()
}
pub fn take_context(&mut self) -> Context {
self.context.take().unwrap_or_else(|| Context::new())
}
pub fn get_start_ts(&self) -> u64 {
self.start_ts
}
pub fn clear_start_ts(&mut self) {
self.start_ts = 0;
}
pub fn set_start_ts(&mut self, v: u64) {
self.start_ts = v;
}
}
impl ::protobuf::Message for MvccGetByStartTsRequest {
fn is_initialized(&self) -> bool {
for v in &self.context {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.context)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_ts = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.context.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.start_ts != 0 {
my_size += ::protobuf::rt::value_size(2, self.start_ts, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.context.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.start_ts != 0 {
os.write_uint64(2, self.start_ts)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> MvccGetByStartTsRequest {
MvccGetByStartTsRequest::new()
}
fn default_instance() -> &'static MvccGetByStartTsRequest {
static mut instance: ::protobuf::lazy::Lazy<MvccGetByStartTsRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const MvccGetByStartTsRequest,
};
unsafe {
instance.get(MvccGetByStartTsRequest::new)
}
}
}
impl ::protobuf::Clear for MvccGetByStartTsRequest {
fn clear(&mut self) {
self.context.clear();
self.start_ts = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for MvccGetByStartTsRequest {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.context, "context", buf);
::protobuf::PbPrint::fmt(&self.start_ts, "start_ts", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for MvccGetByStartTsRequest {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.context, "context", &mut s);
::protobuf::PbPrint::fmt(&self.start_ts, "start_ts", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for MvccGetByStartTsRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct MvccGetByStartTsResponse {
pub region_error: ::protobuf::SingularPtrField<super::errorpb::Error>,
pub error: ::std::string::String,
pub key: ::std::vec::Vec<u8>,
pub info: ::protobuf::SingularPtrField<MvccInfo>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MvccGetByStartTsResponse {
fn default() -> &'a MvccGetByStartTsResponse {
<MvccGetByStartTsResponse as ::protobuf::Message>::default_instance()
}
}
impl MvccGetByStartTsResponse {
pub fn new() -> MvccGetByStartTsResponse {
::std::default::Default::default()
}
pub fn get_region_error(&self) -> &super::errorpb::Error {
self.region_error.as_ref().unwrap_or_else(|| super::errorpb::Error::default_instance())
}
pub fn clear_region_error(&mut self) {
self.region_error.clear();
}
pub fn has_region_error(&self) -> bool {
self.region_error.is_some()
}
pub fn set_region_error(&mut self, v: super::errorpb::Error) {
self.region_error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_error(&mut self) -> &mut super::errorpb::Error {
if self.region_error.is_none() {
self.region_error.set_default();
}
self.region_error.as_mut().unwrap()
}
pub fn take_region_error(&mut self) -> super::errorpb::Error {
self.region_error.take().unwrap_or_else(|| super::errorpb::Error::new())
}
pub fn get_error(&self) -> &str {
&self.error
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn set_error(&mut self, v: ::std::string::String) {
self.error = v;
}
pub fn mut_error(&mut self) -> &mut ::std::string::String {
&mut self.error
}
pub fn take_error(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error, ::std::string::String::new())
}
pub fn get_key(&self) -> &[u8] {
&self.key
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
self.key = v;
}
pub fn mut_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.key
}
pub fn take_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.key, ::std::vec::Vec::new())
}
pub fn get_info(&self) -> &MvccInfo {
self.info.as_ref().unwrap_or_else(|| MvccInfo::default_instance())
}
pub fn clear_info(&mut self) {
self.info.clear();
}
pub fn has_info(&self) -> bool {
self.info.is_some()
}
pub fn set_info(&mut self, v: MvccInfo) {
self.info = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_info(&mut self) -> &mut MvccInfo {
if self.info.is_none() {
self.info.set_default();
}
self.info.as_mut().unwrap()
}
pub fn take_info(&mut self) -> MvccInfo {
self.info.take().unwrap_or_else(|| MvccInfo::new())
}
}
impl ::protobuf::Message for MvccGetByStartTsResponse {
fn is_initialized(&self) -> bool {
for v in &self.region_error {
if !v.is_initialized() {
return false;
}
};
for v in &self.info {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_error)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.error)?;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?;
},
4 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.info)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.region_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.error.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.error);
}
if !self.key.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.key);
}
if let Some(ref v) = self.info.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.region_error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.error.is_empty() {
os.write_string(2, &self.error)?;
}
if !self.key.is_empty() {
os.write_bytes(3, &self.key)?;
}
if let Some(ref v) = self.info.as_ref() {
os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> MvccGetByStartTsResponse {
MvccGetByStartTsResponse::new()
}
fn default_instance() -> &'static MvccGetByStartTsResponse {
static mut instance: ::protobuf::lazy::Lazy<MvccGetByStartTsResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const MvccGetByStartTsResponse,
};
unsafe {
instance.get(MvccGetByStartTsResponse::new)
}
}
}
impl ::protobuf::Clear for MvccGetByStartTsResponse {
fn clear(&mut self) {
self.region_error.clear();
self.error.clear();
self.key.clear();
self.info.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for MvccGetByStartTsResponse {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", buf);
::protobuf::PbPrint::fmt(&self.error, "error", buf);
::protobuf::PbPrint::fmt(&self.key, "key", buf);
::protobuf::PbPrint::fmt(&self.info, "info", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for MvccGetByStartTsResponse {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_error, "region_error", &mut s);
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
::protobuf::PbPrint::fmt(&self.key, "key", &mut s);
::protobuf::PbPrint::fmt(&self.info, "info", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for MvccGetByStartTsResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Context {
pub region_id: u64,
pub region_epoch: ::protobuf::SingularPtrField<super::metapb::RegionEpoch>,
pub peer: ::protobuf::SingularPtrField<super::metapb::Peer>,
pub term: u64,
pub priority: CommandPri,
pub isolation_level: IsolationLevel,
pub not_fill_cache: bool,
pub sync_log: bool,
pub record_time_stat: bool,
pub record_scan_stat: bool,
pub replica_read: bool,
pub resolved_locks: ::std::vec::Vec<u64>,
pub max_execution_duration_ms: u64,
pub applied_index: u64,
pub task_id: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Context {
fn default() -> &'a Context {
<Context as ::protobuf::Message>::default_instance()
}
}
impl Context {
pub fn new() -> Context {
::std::default::Default::default()
}
pub fn get_region_id(&self) -> u64 {
self.region_id
}
pub fn clear_region_id(&mut self) {
self.region_id = 0;
}
pub fn set_region_id(&mut self, v: u64) {
self.region_id = v;
}
pub fn get_region_epoch(&self) -> &super::metapb::RegionEpoch {
self.region_epoch.as_ref().unwrap_or_else(|| super::metapb::RegionEpoch::default_instance())
}
pub fn clear_region_epoch(&mut self) {
self.region_epoch.clear();
}
pub fn has_region_epoch(&self) -> bool {
self.region_epoch.is_some()
}
pub fn set_region_epoch(&mut self, v: super::metapb::RegionEpoch) {
self.region_epoch = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_region_epoch(&mut self) -> &mut super::metapb::RegionEpoch {
if self.region_epoch.is_none() {
self.region_epoch.set_default();
}
self.region_epoch.as_mut().unwrap()
}
pub fn take_region_epoch(&mut self) -> super::metapb::RegionEpoch {
self.region_epoch.take().unwrap_or_else(|| super::metapb::RegionEpoch::new())
}
pub fn get_peer(&self) -> &super::metapb::Peer {
self.peer.as_ref().unwrap_or_else(|| super::metapb::Peer::default_instance())
}
pub fn clear_peer(&mut self) {
self.peer.clear();
}
pub fn has_peer(&self) -> bool {
self.peer.is_some()
}
pub fn set_peer(&mut self, v: super::metapb::Peer) {
self.peer = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_peer(&mut self) -> &mut super::metapb::Peer {
if self.peer.is_none() {
self.peer.set_default();
}
self.peer.as_mut().unwrap()
}
pub fn take_peer(&mut self) -> super::metapb::Peer {
self.peer.take().unwrap_or_else(|| super::metapb::Peer::new())
}
pub fn get_term(&self) -> u64 {
self.term
}
pub fn clear_term(&mut self) {
self.term = 0;
}
pub fn set_term(&mut self, v: u64) {
self.term = v;
}
pub fn get_priority(&self) -> CommandPri {
self.priority
}
pub fn clear_priority(&mut self) {
self.priority = CommandPri::Normal;
}
pub fn set_priority(&mut self, v: CommandPri) {
self.priority = v;
}
pub fn get_isolation_level(&self) -> IsolationLevel {
self.isolation_level
}
pub fn clear_isolation_level(&mut self) {
self.isolation_level = IsolationLevel::Si;
}
pub fn set_isolation_level(&mut self, v: IsolationLevel) {
self.isolation_level = v;
}
pub fn get_not_fill_cache(&self) -> bool {
self.not_fill_cache
}
pub fn clear_not_fill_cache(&mut self) {
self.not_fill_cache = false;
}
pub fn set_not_fill_cache(&mut self, v: bool) {
self.not_fill_cache = v;
}
pub fn get_sync_log(&self) -> bool {
self.sync_log
}
pub fn clear_sync_log(&mut self) {
self.sync_log = false;
}
pub fn set_sync_log(&mut self, v: bool) {
self.sync_log = v;
}
pub fn get_record_time_stat(&self) -> bool {
self.record_time_stat
}
pub fn clear_record_time_stat(&mut self) {
self.record_time_stat = false;
}
pub fn set_record_time_stat(&mut self, v: bool) {
self.record_time_stat = v;
}
pub fn get_record_scan_stat(&self) -> bool {
self.record_scan_stat
}
pub fn clear_record_scan_stat(&mut self) {
self.record_scan_stat = false;
}
pub fn set_record_scan_stat(&mut self, v: bool) {
self.record_scan_stat = v;
}
pub fn get_replica_read(&self) -> bool {
self.replica_read
}
pub fn clear_replica_read(&mut self) {
self.replica_read = false;
}
pub fn set_replica_read(&mut self, v: bool) {
self.replica_read = v;
}
pub fn get_resolved_locks(&self) -> &[u64] {
&self.resolved_locks
}
pub fn clear_resolved_locks(&mut self) {
self.resolved_locks.clear();
}
pub fn set_resolved_locks(&mut self, v: ::std::vec::Vec<u64>) {
self.resolved_locks = v;
}
pub fn mut_resolved_locks(&mut self) -> &mut ::std::vec::Vec<u64> {
&mut self.resolved_locks
}
pub fn take_resolved_locks(&mut self) -> ::std::vec::Vec<u64> {
::std::mem::replace(&mut self.resolved_locks, ::std::vec::Vec::new())
}
pub fn get_max_execution_duration_ms(&self) -> u64 {
self.max_execution_duration_ms
}
pub fn clear_max_execution_duration_ms(&mut self) {
self.max_execution_duration_ms = 0;
}
pub fn set_max_execution_duration_ms(&mut self, v: u64) {
self.max_execution_duration_ms = v;
}
pub fn get_applied_index(&self) -> u64 {
self.applied_index
}
pub fn clear_applied_index(&mut self) {
self.applied_index = 0;
}
pub fn set_applied_index(&mut self, v: u64) {
self.applied_index = v;
}
pub fn get_task_id(&self) -> u64 {
self.task_id
}
pub fn clear_task_id(&mut self) {
self.task_id = 0;
}
pub fn set_task_id(&mut self, v: u64) {
self.task_id = v;
}
}
impl ::protobuf::Message for Context {
fn is_initialized(&self) -> bool {
for v in &self.region_epoch {
if !v.is_initialized() {
return false;
}
};
for v in &self.peer {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.region_id = tmp;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.region_epoch)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.peer)?;
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.term = tmp;
},
6 => {
if wire_type == ::protobuf::wire_format::WireTypeVarint {self.priority = is.read_enum()?;} else {return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));}
},
7 => {
if wire_type == ::protobuf::wire_format::WireTypeVarint {self.isolation_level = is.read_enum()?;} else {return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));}
},
8 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.not_fill_cache = tmp;
},
9 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.sync_log = tmp;
},
10 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.record_time_stat = tmp;
},
11 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.record_scan_stat = tmp;
},
12 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.replica_read = tmp;
},
13 => {
::protobuf::rt::read_repeated_uint64_into(wire_type, is, &mut self.resolved_locks)?;
},
14 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.max_execution_duration_ms = tmp;
},
15 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.applied_index = tmp;
},
16 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.task_id = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.region_id != 0 {
my_size += ::protobuf::rt::value_size(1, self.region_id, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.region_epoch.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.peer.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.term != 0 {
my_size += ::protobuf::rt::value_size(5, self.term, ::protobuf::wire_format::WireTypeVarint);
}
if self.priority != CommandPri::Normal {
my_size += ::protobuf::rt::enum_size(6, self.priority);
}
if self.isolation_level != IsolationLevel::Si {
my_size += ::protobuf::rt::enum_size(7, self.isolation_level);
}
if self.not_fill_cache != false {
my_size += 2;
}
if self.sync_log != false {
my_size += 2;
}
if self.record_time_stat != false {
my_size += 2;
}
if self.record_scan_stat != false {
my_size += 2;
}
if self.replica_read != false {
my_size += 2;
}
for value in &self.resolved_locks {
my_size += ::protobuf::rt::value_size(13, *value, ::protobuf::wire_format::WireTypeVarint);
};
if self.max_execution_duration_ms != 0 {
my_size += ::protobuf::rt::value_size(14, self.max_execution_duration_ms, ::protobuf::wire_format::WireTypeVarint);
}
if self.applied_index != 0 {
my_size += ::protobuf::rt::value_size(15, self.applied_index, ::protobuf::wire_format::WireTypeVarint);
}
if self.task_id != 0 {
my_size += ::protobuf::rt::value_size(16, self.task_id, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.region_id != 0 {
os.write_uint64(1, self.region_id)?;
}
if let Some(ref v) = self.region_epoch.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.peer.as_ref() {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.term != 0 {
os.write_uint64(5, self.term)?;
}
if self.priority != CommandPri::Normal {
os.write_enum(6, self.priority.value())?;
}
if self.isolation_level != IsolationLevel::Si {
os.write_enum(7, self.isolation_level.value())?;
}
if self.not_fill_cache != false {
os.write_bool(8, self.not_fill_cache)?;
}
if self.sync_log != false {
os.write_bool(9, self.sync_log)?;
}
if self.record_time_stat != false {
os.write_bool(10, self.record_time_stat)?;
}
if self.record_scan_stat != false {
os.write_bool(11, self.record_scan_stat)?;
}
if self.replica_read != false {
os.write_bool(12, self.replica_read)?;
}
for v in &self.resolved_locks {
os.write_uint64(13, *v)?;
};
if self.max_execution_duration_ms != 0 {
os.write_uint64(14, self.max_execution_duration_ms)?;
}
if self.applied_index != 0 {
os.write_uint64(15, self.applied_index)?;
}
if self.task_id != 0 {
os.write_uint64(16, self.task_id)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Context {
Context::new()
}
fn default_instance() -> &'static Context {
static mut instance: ::protobuf::lazy::Lazy<Context> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Context,
};
unsafe {
instance.get(Context::new)
}
}
}
impl ::protobuf::Clear for Context {
fn clear(&mut self) {
self.region_id = 0;
self.region_epoch.clear();
self.peer.clear();
self.term = 0;
self.priority = CommandPri::Normal;
self.isolation_level = IsolationLevel::Si;
self.not_fill_cache = false;
self.sync_log = false;
self.record_time_stat = false;
self.record_scan_stat = false;
self.replica_read = false;
self.resolved_locks.clear();
self.max_execution_duration_ms = 0;
self.applied_index = 0;
self.task_id = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for Context {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.region_id, "region_id", buf);
::protobuf::PbPrint::fmt(&self.region_epoch, "region_epoch", buf);
::protobuf::PbPrint::fmt(&self.peer, "peer", buf);
::protobuf::PbPrint::fmt(&self.term, "term", buf);
::protobuf::PbPrint::fmt(&self.priority, "priority", buf);
::protobuf::PbPrint::fmt(&self.isolation_level, "isolation_level", buf);
::protobuf::PbPrint::fmt(&self.not_fill_cache, "not_fill_cache", buf);
::protobuf::PbPrint::fmt(&self.sync_log, "sync_log", buf);
::protobuf::PbPrint::fmt(&self.record_time_stat, "record_time_stat", buf);
::protobuf::PbPrint::fmt(&self.record_scan_stat, "record_scan_stat", buf);
::protobuf::PbPrint::fmt(&self.replica_read, "replica_read", buf);
::protobuf::PbPrint::fmt(&self.resolved_locks, "resolved_locks", buf);
::protobuf::PbPrint::fmt(&self.max_execution_duration_ms, "max_execution_duration_ms", buf);
::protobuf::PbPrint::fmt(&self.applied_index, "applied_index", buf);
::protobuf::PbPrint::fmt(&self.task_id, "task_id", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for Context {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.region_id, "region_id", &mut s);
::protobuf::PbPrint::fmt(&self.region_epoch, "region_epoch", &mut s);
::protobuf::PbPrint::fmt(&self.peer, "peer", &mut s);
::protobuf::PbPrint::fmt(&self.term, "term", &mut s);
::protobuf::PbPrint::fmt(&self.priority, "priority", &mut s);
::protobuf::PbPrint::fmt(&self.isolation_level, "isolation_level", &mut s);
::protobuf::PbPrint::fmt(&self.not_fill_cache, "not_fill_cache", &mut s);
::protobuf::PbPrint::fmt(&self.sync_log, "sync_log", &mut s);
::protobuf::PbPrint::fmt(&self.record_time_stat, "record_time_stat", &mut s);
::protobuf::PbPrint::fmt(&self.record_scan_stat, "record_scan_stat", &mut s);
::protobuf::PbPrint::fmt(&self.replica_read, "replica_read", &mut s);
::protobuf::PbPrint::fmt(&self.resolved_locks, "resolved_locks", &mut s);
::protobuf::PbPrint::fmt(&self.max_execution_duration_ms, "max_execution_duration_ms", &mut s);
::protobuf::PbPrint::fmt(&self.applied_index, "applied_index", &mut s);
::protobuf::PbPrint::fmt(&self.task_id, "task_id", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for Context {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct LockInfo {
pub primary_lock: ::std::vec::Vec<u8>,
pub lock_version: u64,
pub key: ::std::vec::Vec<u8>,
pub lock_ttl: u64,
pub txn_size: u64,
pub lock_type: Op,
pub lock_for_update_ts: u64,
pub use_async_commit: bool,
pub min_commit_ts: u64,
pub secondaries: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a LockInfo {
fn default() -> &'a LockInfo {
<LockInfo as ::protobuf::Message>::default_instance()
}
}
impl LockInfo {
pub fn new() -> LockInfo {
::std::default::Default::default()
}
pub fn get_primary_lock(&self) -> &[u8] {
&self.primary_lock
}
pub fn clear_primary_lock(&mut self) {
self.primary_lock.clear();
}
pub fn set_primary_lock(&mut self, v: ::std::vec::Vec<u8>) {
self.primary_lock = v;
}
pub fn mut_primary_lock(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.primary_lock
}
pub fn take_primary_lock(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.primary_lock, ::std::vec::Vec::new())
}
pub fn get_lock_version(&self) -> u64 {
self.lock_version
}
pub fn clear_lock_version(&mut self) {
self.lock_version = 0;
}
pub fn set_lock_version(&mut self, v: u64) {
self.lock_version = v;
}
pub fn get_key(&self) -> &[u8] {
&self.key
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
self.key = v;
}
pub fn mut_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.key
}
pub fn take_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.key, ::std::vec::Vec::new())
}
pub fn get_lock_ttl(&self) -> u64 {
self.lock_ttl
}
pub fn clear_lock_ttl(&mut self) {
self.lock_ttl = 0;
}
pub fn set_lock_ttl(&mut self, v: u64) {
self.lock_ttl = v;
}
pub fn get_txn_size(&self) -> u64 {
self.txn_size
}
pub fn clear_txn_size(&mut self) {
self.txn_size = 0;
}
pub fn set_txn_size(&mut self, v: u64) {
self.txn_size = v;
}
pub fn get_lock_type(&self) -> Op {
self.lock_type
}
pub fn clear_lock_type(&mut self) {
self.lock_type = Op::Put;
}
pub fn set_lock_type(&mut self, v: Op) {
self.lock_type = v;
}
pub fn get_lock_for_update_ts(&self) -> u64 {
self.lock_for_update_ts
}
pub fn clear_lock_for_update_ts(&mut self) {
self.lock_for_update_ts = 0;
}
pub fn set_lock_for_update_ts(&mut self, v: u64) {
self.lock_for_update_ts = v;
}
pub fn get_use_async_commit(&self) -> bool {
self.use_async_commit
}
pub fn clear_use_async_commit(&mut self) {
self.use_async_commit = false;
}
pub fn set_use_async_commit(&mut self, v: bool) {
self.use_async_commit = v;
}
pub fn get_min_commit_ts(&self) -> u64 {
self.min_commit_ts
}
pub fn clear_min_commit_ts(&mut self) {
self.min_commit_ts = 0;
}
pub fn set_min_commit_ts(&mut self, v: u64) {
self.min_commit_ts = v;
}
pub fn get_secondaries(&self) -> &[::std::vec::Vec<u8>] {
&self.secondaries
}
pub fn clear_secondaries(&mut self) {
self.secondaries.clear();
}
pub fn set_secondaries(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
self.secondaries = v;
}
pub fn mut_secondaries(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
&mut self.secondaries
}
pub fn take_secondaries(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
::std::mem::replace(&mut self.secondaries, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for LockInfo {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.primary_lock)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.lock_version = tmp;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.lock_ttl = tmp;
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.txn_size = tmp;
},
6 => {
if wire_type == ::protobuf::wire_format::WireTypeVarint {self.lock_type = is.read_enum()?;} else {return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));}
},
7 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.lock_for_update_ts = tmp;
},
8 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.use_async_commit = tmp;
},
9 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.min_commit_ts = tmp;
},
10 => {
::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.secondaries)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.primary_lock.is_empty() {
my_size += ::protobuf::rt::bytes_size(1, &self.primary_lock);
}
if self.lock_version != 0 {
my_size += ::protobuf::rt::value_size(2, self.lock_version, ::protobuf::wire_format::WireTypeVarint);
}
if !self.key.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.key);
}
if self.lock_ttl != 0 {
my_size += ::protobuf::rt::value_size(4, self.lock_ttl, ::protobuf::wire_format::WireTypeVarint);
}
if self.txn_size != 0 {
my_size += ::protobuf::rt::value_size(5, self.txn_size, ::protobuf::wire_format::WireTypeVarint);
}
if self.lock_type != Op::Put {
my_size += ::protobuf::rt::enum_size(6, self.lock_type);
}
if self.lock_for_update_ts != 0 {
my_size += ::protobuf::rt::value_size(7, self.lock_for_update_ts, ::protobuf::wire_format::WireTypeVarint);
}
if self.use_async_commit != false {
my_size += 2;
}
if self.min_commit_ts != 0 {
my_size += ::protobuf::rt::value_size(9, self.min_commit_ts, ::protobuf::wire_format::WireTypeVarint);
}
for value in &self.secondaries {
my_size += ::protobuf::rt::bytes_size(10, &value);
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.primary_lock.is_empty() {
os.write_bytes(1, &self.primary_lock)?;
}
if self.lock_version != 0 {
os.write_uint64(2, self.lock_version)?;
}
if !self.key.is_empty() {
os.write_bytes(3, &self.key)?;
}
if self.lock_ttl != 0 {
os.write_uint64(4, self.lock_ttl)?;
}
if self.txn_size != 0 {
os.write_uint64(5, self.txn_size)?;
}
if self.lock_type != Op::Put {
os.write_enum(6, self.lock_type.value())?;
}
if self.lock_for_update_ts != 0 {
os.write_uint64(7, self.lock_for_update_ts)?;
}
if self.use_async_commit != false {
os.write_bool(8, self.use_async_commit)?;
}
if self.min_commit_ts != 0 {
os.write_uint64(9, self.min_commit_ts)?;
}
for v in &self.secondaries {
os.write_bytes(10, &v)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> LockInfo {
LockInfo::new()
}
fn default_instance() -> &'static LockInfo {
static mut instance: ::protobuf::lazy::Lazy<LockInfo> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const LockInfo,
};
unsafe {
instance.get(LockInfo::new)
}
}
}
impl ::protobuf::Clear for LockInfo {
fn clear(&mut self) {
self.primary_lock.clear();
self.lock_version = 0;
self.key.clear();
self.lock_ttl = 0;
self.txn_size = 0;
self.lock_type = Op::Put;
self.lock_for_update_ts = 0;
self.use_async_commit = false;
self.min_commit_ts = 0;
self.secondaries.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for LockInfo {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.primary_lock, "primary_lock", buf);
::protobuf::PbPrint::fmt(&self.lock_version, "lock_version", buf);
::protobuf::PbPrint::fmt(&self.key, "key", buf);
::protobuf::PbPrint::fmt(&self.lock_ttl, "lock_ttl", buf);
::protobuf::PbPrint::fmt(&self.txn_size, "txn_size", buf);
::protobuf::PbPrint::fmt(&self.lock_type, "lock_type", buf);
::protobuf::PbPrint::fmt(&self.lock_for_update_ts, "lock_for_update_ts", buf);
::protobuf::PbPrint::fmt(&self.use_async_commit, "use_async_commit", buf);
::protobuf::PbPrint::fmt(&self.min_commit_ts, "min_commit_ts", buf);
::protobuf::PbPrint::fmt(&self.secondaries, "secondaries", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for LockInfo {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.primary_lock, "primary_lock", &mut s);
::protobuf::PbPrint::fmt(&self.lock_version, "lock_version", &mut s);
::protobuf::PbPrint::fmt(&self.key, "key", &mut s);
::protobuf::PbPrint::fmt(&self.lock_ttl, "lock_ttl", &mut s);
::protobuf::PbPrint::fmt(&self.txn_size, "txn_size", &mut s);
::protobuf::PbPrint::fmt(&self.lock_type, "lock_type", &mut s);
::protobuf::PbPrint::fmt(&self.lock_for_update_ts, "lock_for_update_ts", &mut s);
::protobuf::PbPrint::fmt(&self.use_async_commit, "use_async_commit", &mut s);
::protobuf::PbPrint::fmt(&self.min_commit_ts, "min_commit_ts", &mut s);
::protobuf::PbPrint::fmt(&self.secondaries, "secondaries", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for LockInfo {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct KeyError {
pub locked: ::protobuf::SingularPtrField<LockInfo>,
pub retryable: ::std::string::String,
pub abort: ::std::string::String,
pub conflict: ::protobuf::SingularPtrField<WriteConflict>,
pub already_exist: ::protobuf::SingularPtrField<AlreadyExist>,
pub deadlock: ::protobuf::SingularPtrField<Deadlock>,
pub commit_ts_expired: ::protobuf::SingularPtrField<CommitTsExpired>,
pub txn_not_found: ::protobuf::SingularPtrField<TxnNotFound>,
pub commit_ts_too_large: ::protobuf::SingularPtrField<CommitTsTooLarge>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a KeyError {
fn default() -> &'a KeyError {
<KeyError as ::protobuf::Message>::default_instance()
}
}
impl KeyError {
pub fn new() -> KeyError {
::std::default::Default::default()
}
pub fn get_locked(&self) -> &LockInfo {
self.locked.as_ref().unwrap_or_else(|| LockInfo::default_instance())
}
pub fn clear_locked(&mut self) {
self.locked.clear();
}
pub fn has_locked(&self) -> bool {
self.locked.is_some()
}
pub fn set_locked(&mut self, v: LockInfo) {
self.locked = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_locked(&mut self) -> &mut LockInfo {
if self.locked.is_none() {
self.locked.set_default();
}
self.locked.as_mut().unwrap()
}
pub fn take_locked(&mut self) -> LockInfo {
self.locked.take().unwrap_or_else(|| LockInfo::new())
}
pub fn get_retryable(&self) -> &str {
&self.retryable
}
pub fn clear_retryable(&mut self) {
self.retryable.clear();
}
pub fn set_retryable(&mut self, v: ::std::string::String) {
self.retryable = v;
}
pub fn mut_retryable(&mut self) -> &mut ::std::string::String {
&mut self.retryable
}
pub fn take_retryable(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.retryable, ::std::string::String::new())
}
pub fn get_abort(&self) -> &str {
&self.abort
}
pub fn clear_abort(&mut self) {
self.abort.clear();
}
pub fn set_abort(&mut self, v: ::std::string::String) {
self.abort = v;
}
pub fn mut_abort(&mut self) -> &mut ::std::string::String {
&mut self.abort
}
pub fn take_abort(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.abort, ::std::string::String::new())
}
pub fn get_conflict(&self) -> &WriteConflict {
self.conflict.as_ref().unwrap_or_else(|| WriteConflict::default_instance())
}
pub fn clear_conflict(&mut self) {
self.conflict.clear();
}
pub fn has_conflict(&self) -> bool {
self.conflict.is_some()
}
pub fn set_conflict(&mut self, v: WriteConflict) {
self.conflict = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_conflict(&mut self) -> &mut WriteConflict {
if self.conflict.is_none() {
self.conflict.set_default();
}
self.conflict.as_mut().unwrap()
}
pub fn take_conflict(&mut self) -> WriteConflict {
self.conflict.take().unwrap_or_else(|| WriteConflict::new())
}
pub fn get_already_exist(&self) -> &AlreadyExist {
self.already_exist.as_ref().unwrap_or_else(|| AlreadyExist::default_instance())
}
pub fn clear_already_exist(&mut self) {
self.already_exist.clear();
}
pub fn has_already_exist(&self) -> bool {
self.already_exist.is_some()
}
pub fn set_already_exist(&mut self, v: AlreadyExist) {
self.already_exist = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_already_exist(&mut self) -> &mut AlreadyExist {
if self.already_exist.is_none() {
self.already_exist.set_default();
}
self.already_exist.as_mut().unwrap()
}
pub fn take_already_exist(&mut self) -> AlreadyExist {
self.already_exist.take().unwrap_or_else(|| AlreadyExist::new())
}
pub fn get_deadlock(&self) -> &Deadlock {
self.deadlock.as_ref().unwrap_or_else(|| Deadlock::default_instance())
}
pub fn clear_deadlock(&mut self) {
self.deadlock.clear();
}
pub fn has_deadlock(&self) -> bool {
self.deadlock.is_some()
}
pub fn set_deadlock(&mut self, v: Deadlock) {
self.deadlock = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_deadlock(&mut self) -> &mut Deadlock {
if self.deadlock.is_none() {
self.deadlock.set_default();
}
self.deadlock.as_mut().unwrap()
}
pub fn take_deadlock(&mut self) -> Deadlock {
self.deadlock.take().unwrap_or_else(|| Deadlock::new())
}
pub fn get_commit_ts_expired(&self) -> &CommitTsExpired {
self.commit_ts_expired.as_ref().unwrap_or_else(|| CommitTsExpired::default_instance())
}
pub fn clear_commit_ts_expired(&mut self) {
self.commit_ts_expired.clear();
}
pub fn has_commit_ts_expired(&self) -> bool {
self.commit_ts_expired.is_some()
}
pub fn set_commit_ts_expired(&mut self, v: CommitTsExpired) {
self.commit_ts_expired = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_commit_ts_expired(&mut self) -> &mut CommitTsExpired {
if self.commit_ts_expired.is_none() {
self.commit_ts_expired.set_default();
}
self.commit_ts_expired.as_mut().unwrap()
}
pub fn take_commit_ts_expired(&mut self) -> CommitTsExpired {
self.commit_ts_expired.take().unwrap_or_else(|| CommitTsExpired::new())
}
pub fn get_txn_not_found(&self) -> &TxnNotFound {
self.txn_not_found.as_ref().unwrap_or_else(|| TxnNotFound::default_instance())
}
pub fn clear_txn_not_found(&mut self) {
self.txn_not_found.clear();
}
pub fn has_txn_not_found(&self) -> bool {
self.txn_not_found.is_some()
}
pub fn set_txn_not_found(&mut self, v: TxnNotFound) {
self.txn_not_found = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_txn_not_found(&mut self) -> &mut TxnNotFound {
if self.txn_not_found.is_none() {
self.txn_not_found.set_default();
}
self.txn_not_found.as_mut().unwrap()
}
pub fn take_txn_not_found(&mut self) -> TxnNotFound {
self.txn_not_found.take().unwrap_or_else(|| TxnNotFound::new())
}
pub fn get_commit_ts_too_large(&self) -> &CommitTsTooLarge {
self.commit_ts_too_large.as_ref().unwrap_or_else(|| CommitTsTooLarge::default_instance())
}
pub fn clear_commit_ts_too_large(&mut self) {
self.commit_ts_too_large.clear();
}
pub fn has_commit_ts_too_large(&self) -> bool {
self.commit_ts_too_large.is_some()
}
pub fn set_commit_ts_too_large(&mut self, v: CommitTsTooLarge) {
self.commit_ts_too_large = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_commit_ts_too_large(&mut self) -> &mut CommitTsTooLarge {
if self.commit_ts_too_large.is_none() {
self.commit_ts_too_large.set_default();
}
self.commit_ts_too_large.as_mut().unwrap()
}
pub fn take_commit_ts_too_large(&mut self) -> CommitTsTooLarge {
self.commit_ts_too_large.take().unwrap_or_else(|| CommitTsTooLarge::new())
}
}
impl ::protobuf::Message for KeyError {
fn is_initialized(&self) -> bool {
for v in &self.locked {
if !v.is_initialized() {
return false;
}
};
for v in &self.conflict {
if !v.is_initialized() {
return false;
}
};
for v in &self.already_exist {
if !v.is_initialized() {
return false;
}
};
for v in &self.deadlock {
if !v.is_initialized() {
return false;
}
};
for v in &self.commit_ts_expired {
if !v.is_initialized() {
return false;
}
};
for v in &self.txn_not_found {
if !v.is_initialized() {
return false;
}
};
for v in &self.commit_ts_too_large {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.locked)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.retryable)?;
},
3 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.abort)?;
},
4 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.conflict)?;
},
5 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.already_exist)?;
},
6 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.deadlock)?;
},
7 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.commit_ts_expired)?;
},
8 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.txn_not_found)?;
},
9 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.commit_ts_too_large)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.locked.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.retryable.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.retryable);
}
if !self.abort.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.abort);
}
if let Some(ref v) = self.conflict.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.already_exist.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.deadlock.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.commit_ts_expired.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.txn_not_found.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.commit_ts_too_large.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.locked.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.retryable.is_empty() {
os.write_string(2, &self.retryable)?;
}
if !self.abort.is_empty() {
os.write_string(3, &self.abort)?;
}
if let Some(ref v) = self.conflict.as_ref() {
os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.already_exist.as_ref() {
os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.deadlock.as_ref() {
os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.commit_ts_expired.as_ref() {
os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.txn_not_found.as_ref() {
os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.commit_ts_too_large.as_ref() {
os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> KeyError {
KeyError::new()
}
fn default_instance() -> &'static KeyError {
static mut instance: ::protobuf::lazy::Lazy<KeyError> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const KeyError,
};
unsafe {
instance.get(KeyError::new)
}
}
}
impl ::protobuf::Clear for KeyError {
fn clear(&mut self) {
self.locked.clear();
self.retryable.clear();
self.abort.clear();
self.conflict.clear();
self.already_exist.clear();
self.deadlock.clear();
self.commit_ts_expired.clear();
self.txn_not_found.clear();
self.commit_ts_too_large.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for KeyError {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.locked, "locked", buf);
::protobuf::PbPrint::fmt(&self.retryable, "retryable", buf);
::protobuf::PbPrint::fmt(&self.abort, "abort", buf);
::protobuf::PbPrint::fmt(&self.conflict, "conflict", buf);
::protobuf::PbPrint::fmt(&self.already_exist, "already_exist", buf);
::protobuf::PbPrint::fmt(&self.deadlock, "deadlock", buf);
::protobuf::PbPrint::fmt(&self.commit_ts_expired, "commit_ts_expired", buf);
::protobuf::PbPrint::fmt(&self.txn_not_found, "txn_not_found", buf);
::protobuf::PbPrint::fmt(&self.commit_ts_too_large, "commit_ts_too_large", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for KeyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.locked, "locked", &mut s);
::protobuf::PbPrint::fmt(&self.retryable, "retryable", &mut s);
::protobuf::PbPrint::fmt(&self.abort, "abort", &mut s);
::protobuf::PbPrint::fmt(&self.conflict, "conflict", &mut s);
::protobuf::PbPrint::fmt(&self.already_exist, "already_exist", &mut s);
::protobuf::PbPrint::fmt(&self.deadlock, "deadlock", &mut s);
::protobuf::PbPrint::fmt(&self.commit_ts_expired, "commit_ts_expired", &mut s);
::protobuf::PbPrint::fmt(&self.txn_not_found, "txn_not_found", &mut s);
::protobuf::PbPrint::fmt(&self.commit_ts_too_large, "commit_ts_too_large", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for KeyError {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct WriteConflict {
pub start_ts: u64,
pub conflict_ts: u64,
pub key: ::std::vec::Vec<u8>,
pub primary: ::std::vec::Vec<u8>,
pub conflict_commit_ts: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a WriteConflict {
fn default() -> &'a WriteConflict {
<WriteConflict as ::protobuf::Message>::default_instance()
}
}
impl WriteConflict {
pub fn new() -> WriteConflict {
::std::default::Default::default()
}
pub fn get_start_ts(&self) -> u64 {
self.start_ts
}
pub fn clear_start_ts(&mut self) {
self.start_ts = 0;
}
pub fn set_start_ts(&mut self, v: u64) {
self.start_ts = v;
}
pub fn get_conflict_ts(&self) -> u64 {
self.conflict_ts
}
pub fn clear_conflict_ts(&mut self) {
self.conflict_ts = 0;
}
pub fn set_conflict_ts(&mut self, v: u64) {
self.conflict_ts = v;
}
pub fn get_key(&self) -> &[u8] {
&self.key
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
self.key = v;
}
pub fn mut_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.key
}
pub fn take_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.key, ::std::vec::Vec::new())
}
pub fn get_primary(&self) -> &[u8] {
&self.primary
}
pub fn clear_primary(&mut self) {
self.primary.clear();
}
pub fn set_primary(&mut self, v: ::std::vec::Vec<u8>) {
self.primary = v;
}
pub fn mut_primary(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.primary
}
pub fn take_primary(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.primary, ::std::vec::Vec::new())
}
pub fn get_conflict_commit_ts(&self) -> u64 {
self.conflict_commit_ts
}
pub fn clear_conflict_commit_ts(&mut self) {
self.conflict_commit_ts = 0;
}
pub fn set_conflict_commit_ts(&mut self, v: u64) {
self.conflict_commit_ts = v;
}
}
impl ::protobuf::Message for WriteConflict {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_ts = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.conflict_ts = tmp;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?;
},
4 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.primary)?;
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.conflict_commit_ts = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.start_ts != 0 {
my_size += ::protobuf::rt::value_size(1, self.start_ts, ::protobuf::wire_format::WireTypeVarint);
}
if self.conflict_ts != 0 {
my_size += ::protobuf::rt::value_size(2, self.conflict_ts, ::protobuf::wire_format::WireTypeVarint);
}
if !self.key.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.key);
}
if !self.primary.is_empty() {
my_size += ::protobuf::rt::bytes_size(4, &self.primary);
}
if self.conflict_commit_ts != 0 {
my_size += ::protobuf::rt::value_size(5, self.conflict_commit_ts, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.start_ts != 0 {
os.write_uint64(1, self.start_ts)?;
}
if self.conflict_ts != 0 {
os.write_uint64(2, self.conflict_ts)?;
}
if !self.key.is_empty() {
os.write_bytes(3, &self.key)?;
}
if !self.primary.is_empty() {
os.write_bytes(4, &self.primary)?;
}
if self.conflict_commit_ts != 0 {
os.write_uint64(5, self.conflict_commit_ts)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> WriteConflict {
WriteConflict::new()
}
fn default_instance() -> &'static WriteConflict {
static mut instance: ::protobuf::lazy::Lazy<WriteConflict> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const WriteConflict,
};
unsafe {
instance.get(WriteConflict::new)
}
}
}
impl ::protobuf::Clear for WriteConflict {
fn clear(&mut self) {
self.start_ts = 0;
self.conflict_ts = 0;
self.key.clear();
self.primary.clear();
self.conflict_commit_ts = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for WriteConflict {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.start_ts, "start_ts", buf);
::protobuf::PbPrint::fmt(&self.conflict_ts, "conflict_ts", buf);
::protobuf::PbPrint::fmt(&self.key, "key", buf);
::protobuf::PbPrint::fmt(&self.primary, "primary", buf);
::protobuf::PbPrint::fmt(&self.conflict_commit_ts, "conflict_commit_ts", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for WriteConflict {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.start_ts, "start_ts", &mut s);
::protobuf::PbPrint::fmt(&self.conflict_ts, "conflict_ts", &mut s);
::protobuf::PbPrint::fmt(&self.key, "key", &mut s);
::protobuf::PbPrint::fmt(&self.primary, "primary", &mut s);
::protobuf::PbPrint::fmt(&self.conflict_commit_ts, "conflict_commit_ts", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for WriteConflict {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct AlreadyExist {
pub key: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a AlreadyExist {
fn default() -> &'a AlreadyExist {
<AlreadyExist as ::protobuf::Message>::default_instance()
}
}
impl AlreadyExist {
pub fn new() -> AlreadyExist {
::std::default::Default::default()
}
pub fn get_key(&self) -> &[u8] {
&self.key
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
self.key = v;
}
pub fn mut_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.key
}
pub fn take_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.key, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for AlreadyExist {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.key.is_empty() {
my_size += ::protobuf::rt::bytes_size(1, &self.key);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.key.is_empty() {
os.write_bytes(1, &self.key)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> AlreadyExist {
AlreadyExist::new()
}
fn default_instance() -> &'static AlreadyExist {
static mut instance: ::protobuf::lazy::Lazy<AlreadyExist> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const AlreadyExist,
};
unsafe {
instance.get(AlreadyExist::new)
}
}
}
impl ::protobuf::Clear for AlreadyExist {
fn clear(&mut self) {
self.key.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for AlreadyExist {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.key, "key", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for AlreadyExist {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.key, "key", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for AlreadyExist {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Deadlock {
pub lock_ts: u64,
pub lock_key: ::std::vec::Vec<u8>,
pub deadlock_key_hash: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Deadlock {
fn default() -> &'a Deadlock {
<Deadlock as ::protobuf::Message>::default_instance()
}
}
impl Deadlock {
pub fn new() -> Deadlock {
::std::default::Default::default()
}
pub fn get_lock_ts(&self) -> u64 {
self.lock_ts
}
pub fn clear_lock_ts(&mut self) {
self.lock_ts = 0;
}
pub fn set_lock_ts(&mut self, v: u64) {
self.lock_ts = v;
}
pub fn get_lock_key(&self) -> &[u8] {
&self.lock_key
}
pub fn clear_lock_key(&mut self) {
self.lock_key.clear();
}
pub fn set_lock_key(&mut self, v: ::std::vec::Vec<u8>) {
self.lock_key = v;
}
pub fn mut_lock_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.lock_key
}
pub fn take_lock_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.lock_key, ::std::vec::Vec::new())
}
pub fn get_deadlock_key_hash(&self) -> u64 {
self.deadlock_key_hash
}
pub fn clear_deadlock_key_hash(&mut self) {
self.deadlock_key_hash = 0;
}
pub fn set_deadlock_key_hash(&mut self, v: u64) {
self.deadlock_key_hash = v;
}
}
impl ::protobuf::Message for Deadlock {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.lock_ts = tmp;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.lock_key)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.deadlock_key_hash = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.lock_ts != 0 {
my_size += ::protobuf::rt::value_size(1, self.lock_ts, ::protobuf::wire_format::WireTypeVarint);
}
if !self.lock_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.lock_key);
}
if self.deadlock_key_hash != 0 {
my_size += ::protobuf::rt::value_size(3, self.deadlock_key_hash, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.lock_ts != 0 {
os.write_uint64(1, self.lock_ts)?;
}
if !self.lock_key.is_empty() {
os.write_bytes(2, &self.lock_key)?;
}
if self.deadlock_key_hash != 0 {
os.write_uint64(3, self.deadlock_key_hash)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Deadlock {
Deadlock::new()
}
fn default_instance() -> &'static Deadlock {
static mut instance: ::protobuf::lazy::Lazy<Deadlock> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Deadlock,
};
unsafe {
instance.get(Deadlock::new)
}
}
}
impl ::protobuf::Clear for Deadlock {
fn clear(&mut self) {
self.lock_ts = 0;
self.lock_key.clear();
self.deadlock_key_hash = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for Deadlock {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.lock_ts, "lock_ts", buf);
::protobuf::PbPrint::fmt(&self.lock_key, "lock_key", buf);
::protobuf::PbPrint::fmt(&self.deadlock_key_hash, "deadlock_key_hash", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for Deadlock {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.lock_ts, "lock_ts", &mut s);
::protobuf::PbPrint::fmt(&self.lock_key, "lock_key", &mut s);
::protobuf::PbPrint::fmt(&self.deadlock_key_hash, "deadlock_key_hash", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for Deadlock {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CommitTsExpired {
pub start_ts: u64,
pub attempted_commit_ts: u64,
pub key: ::std::vec::Vec<u8>,
pub min_commit_ts: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CommitTsExpired {
fn default() -> &'a CommitTsExpired {
<CommitTsExpired as ::protobuf::Message>::default_instance()
}
}
impl CommitTsExpired {
pub fn new() -> CommitTsExpired {
::std::default::Default::default()
}
pub fn get_start_ts(&self) -> u64 {
self.start_ts
}
pub fn clear_start_ts(&mut self) {
self.start_ts = 0;
}
pub fn set_start_ts(&mut self, v: u64) {
self.start_ts = v;
}
pub fn get_attempted_commit_ts(&self) -> u64 {
self.attempted_commit_ts
}
pub fn clear_attempted_commit_ts(&mut self) {
self.attempted_commit_ts = 0;
}
pub fn set_attempted_commit_ts(&mut self, v: u64) {
self.attempted_commit_ts = v;
}
pub fn get_key(&self) -> &[u8] {
&self.key
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
self.key = v;
}
pub fn mut_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.key
}
pub fn take_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.key, ::std::vec::Vec::new())
}
pub fn get_min_commit_ts(&self) -> u64 {
self.min_commit_ts
}
pub fn clear_min_commit_ts(&mut self) {
self.min_commit_ts = 0;
}
pub fn set_min_commit_ts(&mut self, v: u64) {
self.min_commit_ts = v;
}
}
impl ::protobuf::Message for CommitTsExpired {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_ts = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.attempted_commit_ts = tmp;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.min_commit_ts = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.start_ts != 0 {
my_size += ::protobuf::rt::value_size(1, self.start_ts, ::protobuf::wire_format::WireTypeVarint);
}
if self.attempted_commit_ts != 0 {
my_size += ::protobuf::rt::value_size(2, self.attempted_commit_ts, ::protobuf::wire_format::WireTypeVarint);
}
if !self.key.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.key);
}
if self.min_commit_ts != 0 {
my_size += ::protobuf::rt::value_size(4, self.min_commit_ts, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.start_ts != 0 {
os.write_uint64(1, self.start_ts)?;
}
if self.attempted_commit_ts != 0 {
os.write_uint64(2, self.attempted_commit_ts)?;
}
if !self.key.is_empty() {
os.write_bytes(3, &self.key)?;
}
if self.min_commit_ts != 0 {
os.write_uint64(4, self.min_commit_ts)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CommitTsExpired {
CommitTsExpired::new()
}
fn default_instance() -> &'static CommitTsExpired {
static mut instance: ::protobuf::lazy::Lazy<CommitTsExpired> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CommitTsExpired,
};
unsafe {
instance.get(CommitTsExpired::new)
}
}
}
impl ::protobuf::Clear for CommitTsExpired {
fn clear(&mut self) {
self.start_ts = 0;
self.attempted_commit_ts = 0;
self.key.clear();
self.min_commit_ts = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for CommitTsExpired {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.start_ts, "start_ts", buf);
::protobuf::PbPrint::fmt(&self.attempted_commit_ts, "attempted_commit_ts", buf);
::protobuf::PbPrint::fmt(&self.key, "key", buf);
::protobuf::PbPrint::fmt(&self.min_commit_ts, "min_commit_ts", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for CommitTsExpired {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.start_ts, "start_ts", &mut s);
::protobuf::PbPrint::fmt(&self.attempted_commit_ts, "attempted_commit_ts", &mut s);
::protobuf::PbPrint::fmt(&self.key, "key", &mut s);
::protobuf::PbPrint::fmt(&self.min_commit_ts, "min_commit_ts", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for CommitTsExpired {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxnNotFound {
pub start_ts: u64,
pub primary_key: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxnNotFound {
fn default() -> &'a TxnNotFound {
<TxnNotFound as ::protobuf::Message>::default_instance()
}
}
impl TxnNotFound {
pub fn new() -> TxnNotFound {
::std::default::Default::default()
}
pub fn get_start_ts(&self) -> u64 {
self.start_ts
}
pub fn clear_start_ts(&mut self) {
self.start_ts = 0;
}
pub fn set_start_ts(&mut self, v: u64) {
self.start_ts = v;
}
pub fn get_primary_key(&self) -> &[u8] {
&self.primary_key
}
pub fn clear_primary_key(&mut self) {
self.primary_key.clear();
}
pub fn set_primary_key(&mut self, v: ::std::vec::Vec<u8>) {
self.primary_key = v;
}
pub fn mut_primary_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.primary_key
}
pub fn take_primary_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.primary_key, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for TxnNotFound {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_ts = tmp;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.primary_key)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.start_ts != 0 {
my_size += ::protobuf::rt::value_size(1, self.start_ts, ::protobuf::wire_format::WireTypeVarint);
}
if !self.primary_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.primary_key);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.start_ts != 0 {
os.write_uint64(1, self.start_ts)?;
}
if !self.primary_key.is_empty() {
os.write_bytes(2, &self.primary_key)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> TxnNotFound {
TxnNotFound::new()
}
fn default_instance() -> &'static TxnNotFound {
static mut instance: ::protobuf::lazy::Lazy<TxnNotFound> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const TxnNotFound,
};
unsafe {
instance.get(TxnNotFound::new)
}
}
}
impl ::protobuf::Clear for TxnNotFound {
fn clear(&mut self) {
self.start_ts = 0;
self.primary_key.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for TxnNotFound {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.start_ts, "start_ts", buf);
::protobuf::PbPrint::fmt(&self.primary_key, "primary_key", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for TxnNotFound {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.start_ts, "start_ts", &mut s);
::protobuf::PbPrint::fmt(&self.primary_key, "primary_key", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for TxnNotFound {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CommitTsTooLarge {
pub commit_ts: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CommitTsTooLarge {
fn default() -> &'a CommitTsTooLarge {
<CommitTsTooLarge as ::protobuf::Message>::default_instance()
}
}
impl CommitTsTooLarge {
pub fn new() -> CommitTsTooLarge {
::std::default::Default::default()
}
pub fn get_commit_ts(&self) -> u64 {
self.commit_ts
}
pub fn clear_commit_ts(&mut self) {
self.commit_ts = 0;
}
pub fn set_commit_ts(&mut self, v: u64) {
self.commit_ts = v;
}
}
impl ::protobuf::Message for CommitTsTooLarge {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.commit_ts = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.commit_ts != 0 {
my_size += ::protobuf::rt::value_size(1, self.commit_ts, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.commit_ts != 0 {
os.write_uint64(1, self.commit_ts)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CommitTsTooLarge {
CommitTsTooLarge::new()
}
fn default_instance() -> &'static CommitTsTooLarge {
static mut instance: ::protobuf::lazy::Lazy<CommitTsTooLarge> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CommitTsTooLarge,
};
unsafe {
instance.get(CommitTsTooLarge::new)
}
}
}
impl ::protobuf::Clear for CommitTsTooLarge {
fn clear(&mut self) {
self.commit_ts = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for CommitTsTooLarge {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.commit_ts, "commit_ts", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for CommitTsTooLarge {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.commit_ts, "commit_ts", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for CommitTsTooLarge {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TimeDetail {
pub wait_wall_time_ms: i64,
pub process_wall_time_ms: i64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TimeDetail {
fn default() -> &'a TimeDetail {
<TimeDetail as ::protobuf::Message>::default_instance()
}
}
impl TimeDetail {
pub fn new() -> TimeDetail {
::std::default::Default::default()
}
pub fn get_wait_wall_time_ms(&self) -> i64 {
self.wait_wall_time_ms
}
pub fn clear_wait_wall_time_ms(&mut self) {
self.wait_wall_time_ms = 0;
}
pub fn set_wait_wall_time_ms(&mut self, v: i64) {
self.wait_wall_time_ms = v;
}
pub fn get_process_wall_time_ms(&self) -> i64 {
self.process_wall_time_ms
}
pub fn clear_process_wall_time_ms(&mut self) {
self.process_wall_time_ms = 0;
}
pub fn set_process_wall_time_ms(&mut self, v: i64) {
self.process_wall_time_ms = v;
}
}
impl ::protobuf::Message for TimeDetail {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_int64()?;
self.wait_wall_time_ms = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_int64()?;
self.process_wall_time_ms = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.wait_wall_time_ms != 0 {
my_size += ::protobuf::rt::value_size(1, self.wait_wall_time_ms, ::protobuf::wire_format::WireTypeVarint);
}
if self.process_wall_time_ms != 0 {
my_size += ::protobuf::rt::value_size(2, self.process_wall_time_ms, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.wait_wall_time_ms != 0 {
os.write_int64(1, self.wait_wall_time_ms)?;
}
if self.process_wall_time_ms != 0 {
os.write_int64(2, self.process_wall_time_ms)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> TimeDetail {
TimeDetail::new()
}
fn default_instance() -> &'static TimeDetail {
static mut instance: ::protobuf::lazy::Lazy<TimeDetail> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const TimeDetail,
};
unsafe {
instance.get(TimeDetail::new)
}
}
}
impl ::protobuf::Clear for TimeDetail {
fn clear(&mut self) {
self.wait_wall_time_ms = 0;
self.process_wall_time_ms = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for TimeDetail {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.wait_wall_time_ms, "wait_wall_time_ms", buf);
::protobuf::PbPrint::fmt(&self.process_wall_time_ms, "process_wall_time_ms", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for TimeDetail {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.wait_wall_time_ms, "wait_wall_time_ms", &mut s);
::protobuf::PbPrint::fmt(&self.process_wall_time_ms, "process_wall_time_ms", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for TimeDetail {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ScanInfo {
pub total: i64,
pub processed: i64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ScanInfo {
fn default() -> &'a ScanInfo {
<ScanInfo as ::protobuf::Message>::default_instance()
}
}
impl ScanInfo {
pub fn new() -> ScanInfo {
::std::default::Default::default()
}
pub fn get_total(&self) -> i64 {
self.total
}
pub fn clear_total(&mut self) {
self.total = 0;
}
pub fn set_total(&mut self, v: i64) {
self.total = v;
}
pub fn get_processed(&self) -> i64 {
self.processed
}
pub fn clear_processed(&mut self) {
self.processed = 0;
}
pub fn set_processed(&mut self, v: i64) {
self.processed = v;
}
}
impl ::protobuf::Message for ScanInfo {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_int64()?;
self.total = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_int64()?;
self.processed = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.total != 0 {
my_size += ::protobuf::rt::value_size(1, self.total, ::protobuf::wire_format::WireTypeVarint);
}
if self.processed != 0 {
my_size += ::protobuf::rt::value_size(2, self.processed, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.total != 0 {
os.write_int64(1, self.total)?;
}
if self.processed != 0 {
os.write_int64(2, self.processed)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ScanInfo {
ScanInfo::new()
}
fn default_instance() -> &'static ScanInfo {
static mut instance: ::protobuf::lazy::Lazy<ScanInfo> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ScanInfo,
};
unsafe {
instance.get(ScanInfo::new)
}
}
}
impl ::protobuf::Clear for ScanInfo {
fn clear(&mut self) {
self.total = 0;
self.processed = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for ScanInfo {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.total, "total", buf);
::protobuf::PbPrint::fmt(&self.processed, "processed", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for ScanInfo {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.total, "total", &mut s);
::protobuf::PbPrint::fmt(&self.processed, "processed", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for ScanInfo {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ScanDetail {
pub write: ::protobuf::SingularPtrField<ScanInfo>,
pub lock: ::protobuf::SingularPtrField<ScanInfo>,
pub data: ::protobuf::SingularPtrField<ScanInfo>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ScanDetail {
fn default() -> &'a ScanDetail {
<ScanDetail as ::protobuf::Message>::default_instance()
}
}
impl ScanDetail {
pub fn new() -> ScanDetail {
::std::default::Default::default()
}
pub fn get_write(&self) -> &ScanInfo {
self.write.as_ref().unwrap_or_else(|| ScanInfo::default_instance())
}
pub fn clear_write(&mut self) {
self.write.clear();
}
pub fn has_write(&self) -> bool {
self.write.is_some()
}
pub fn set_write(&mut self, v: ScanInfo) {
self.write = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_write(&mut self) -> &mut ScanInfo {
if self.write.is_none() {
self.write.set_default();
}
self.write.as_mut().unwrap()
}
pub fn take_write(&mut self) -> ScanInfo {
self.write.take().unwrap_or_else(|| ScanInfo::new())
}
pub fn get_lock(&self) -> &ScanInfo {
self.lock.as_ref().unwrap_or_else(|| ScanInfo::default_instance())
}
pub fn clear_lock(&mut self) {
self.lock.clear();
}
pub fn has_lock(&self) -> bool {
self.lock.is_some()
}
pub fn set_lock(&mut self, v: ScanInfo) {
self.lock = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_lock(&mut self) -> &mut ScanInfo {
if self.lock.is_none() {
self.lock.set_default();
}
self.lock.as_mut().unwrap()
}
pub fn take_lock(&mut self) -> ScanInfo {
self.lock.take().unwrap_or_else(|| ScanInfo::new())
}
pub fn get_data(&self) -> &ScanInfo {
self.data.as_ref().unwrap_or_else(|| ScanInfo::default_instance())
}
pub fn clear_data(&mut self) {
self.data.clear();
}
pub fn has_data(&self) -> bool {
self.data.is_some()
}
pub fn set_data(&mut self, v: ScanInfo) {
self.data = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_data(&mut self) -> &mut ScanInfo {
if self.data.is_none() {
self.data.set_default();
}
self.data.as_mut().unwrap()
}
pub fn take_data(&mut self) -> ScanInfo {
self.data.take().unwrap_or_else(|| ScanInfo::new())
}
}
impl ::protobuf::Message for ScanDetail {
fn is_initialized(&self) -> bool {
for v in &self.write {
if !v.is_initialized() {
return false;
}
};
for v in &self.lock {
if !v.is_initialized() {
return false;
}
};
for v in &self.data {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.write)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.lock)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.data)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.write.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.lock.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.data.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.write.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.lock.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.data.as_ref() {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ScanDetail {
ScanDetail::new()
}
fn default_instance() -> &'static ScanDetail {
static mut instance: ::protobuf::lazy::Lazy<ScanDetail> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ScanDetail,
};
unsafe {
instance.get(ScanDetail::new)
}
}
}
impl ::protobuf::Clear for ScanDetail {
fn clear(&mut self) {
self.write.clear();
self.lock.clear();
self.data.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for ScanDetail {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.write, "write", buf);
::protobuf::PbPrint::fmt(&self.lock, "lock", buf);
::protobuf::PbPrint::fmt(&self.data, "data", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for ScanDetail {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.write, "write", &mut s);
::protobuf::PbPrint::fmt(&self.lock, "lock", &mut s);
::protobuf::PbPrint::fmt(&self.data, "data", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for ScanDetail {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ScanDetailV2 {
pub processed_versions: u64,
pub total_versions: u64,
pub rocksdb_delete_skipped_count: u64,
pub rocksdb_key_skipped_count: u64,
pub rocksdb_block_cache_hit_count: u64,
pub rocksdb_block_read_count: u64,
pub rocksdb_block_read_byte: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ScanDetailV2 {
fn default() -> &'a ScanDetailV2 {
<ScanDetailV2 as ::protobuf::Message>::default_instance()
}
}
impl ScanDetailV2 {
pub fn new() -> ScanDetailV2 {
::std::default::Default::default()
}
pub fn get_processed_versions(&self) -> u64 {
self.processed_versions
}
pub fn clear_processed_versions(&mut self) {
self.processed_versions = 0;
}
pub fn set_processed_versions(&mut self, v: u64) {
self.processed_versions = v;
}
pub fn get_total_versions(&self) -> u64 {
self.total_versions
}
pub fn clear_total_versions(&mut self) {
self.total_versions = 0;
}
pub fn set_total_versions(&mut self, v: u64) {
self.total_versions = v;
}
pub fn get_rocksdb_delete_skipped_count(&self) -> u64 {
self.rocksdb_delete_skipped_count
}
pub fn clear_rocksdb_delete_skipped_count(&mut self) {
self.rocksdb_delete_skipped_count = 0;
}
pub fn set_rocksdb_delete_skipped_count(&mut self, v: u64) {
self.rocksdb_delete_skipped_count = v;
}
pub fn get_rocksdb_key_skipped_count(&self) -> u64 {
self.rocksdb_key_skipped_count
}
pub fn clear_rocksdb_key_skipped_count(&mut self) {
self.rocksdb_key_skipped_count = 0;
}
pub fn set_rocksdb_key_skipped_count(&mut self, v: u64) {
self.rocksdb_key_skipped_count = v;
}
pub fn get_rocksdb_block_cache_hit_count(&self) -> u64 {
self.rocksdb_block_cache_hit_count
}
pub fn clear_rocksdb_block_cache_hit_count(&mut self) {
self.rocksdb_block_cache_hit_count = 0;
}
pub fn set_rocksdb_block_cache_hit_count(&mut self, v: u64) {
self.rocksdb_block_cache_hit_count = v;
}
pub fn get_rocksdb_block_read_count(&self) -> u64 {
self.rocksdb_block_read_count
}
pub fn clear_rocksdb_block_read_count(&mut self) {
self.rocksdb_block_read_count = 0;
}
pub fn set_rocksdb_block_read_count(&mut self, v: u64) {
self.rocksdb_block_read_count = v;
}
pub fn get_rocksdb_block_read_byte(&self) -> u64 {
self.rocksdb_block_read_byte
}
pub fn clear_rocksdb_block_read_byte(&mut self) {
self.rocksdb_block_read_byte = 0;
}
pub fn set_rocksdb_block_read_byte(&mut self, v: u64) {
self.rocksdb_block_read_byte = v;
}
}
impl ::protobuf::Message for ScanDetailV2 {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.processed_versions = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total_versions = tmp;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.rocksdb_delete_skipped_count = tmp;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.rocksdb_key_skipped_count = tmp;
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.rocksdb_block_cache_hit_count = tmp;
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.rocksdb_block_read_count = tmp;
},
7 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.rocksdb_block_read_byte = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.processed_versions != 0 {
my_size += ::protobuf::rt::value_size(1, self.processed_versions, ::protobuf::wire_format::WireTypeVarint);
}
if self.total_versions != 0 {
my_size += ::protobuf::rt::value_size(2, self.total_versions, ::protobuf::wire_format::WireTypeVarint);
}
if self.rocksdb_delete_skipped_count != 0 {
my_size += ::protobuf::rt::value_size(3, self.rocksdb_delete_skipped_count, ::protobuf::wire_format::WireTypeVarint);
}
if self.rocksdb_key_skipped_count != 0 {
my_size += ::protobuf::rt::value_size(4, self.rocksdb_key_skipped_count, ::protobuf::wire_format::WireTypeVarint);
}
if self.rocksdb_block_cache_hit_count != 0 {
my_size += ::protobuf::rt::value_size(5, self.rocksdb_block_cache_hit_count, ::protobuf::wire_format::WireTypeVarint);
}
if self.rocksdb_block_read_count != 0 {
my_size += ::protobuf::rt::value_size(6, self.rocksdb_block_read_count, ::protobuf::wire_format::WireTypeVarint);
}
if self.rocksdb_block_read_byte != 0 {
my_size += ::protobuf::rt::value_size(7, self.rocksdb_block_read_byte, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.processed_versions != 0 {
os.write_uint64(1, self.processed_versions)?;
}
if self.total_versions != 0 {
os.write_uint64(2, self.total_versions)?;
}
if self.rocksdb_delete_skipped_count != 0 {
os.write_uint64(3, self.rocksdb_delete_skipped_count)?;
}
if self.rocksdb_key_skipped_count != 0 {
os.write_uint64(4, self.rocksdb_key_skipped_count)?;
}
if self.rocksdb_block_cache_hit_count != 0 {
os.write_uint64(5, self.rocksdb_block_cache_hit_count)?;
}
if self.rocksdb_block_read_count != 0 {
os.write_uint64(6, self.rocksdb_block_read_count)?;
}
if self.rocksdb_block_read_byte != 0 {
os.write_uint64(7, self.rocksdb_block_read_byte)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ScanDetailV2 {
ScanDetailV2::new()
}
fn default_instance() -> &'static ScanDetailV2 {
static mut instance: ::protobuf::lazy::Lazy<ScanDetailV2> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ScanDetailV2,
};
unsafe {
instance.get(ScanDetailV2::new)
}
}
}
impl ::protobuf::Clear for ScanDetailV2 {
fn clear(&mut self) {
self.processed_versions = 0;
self.total_versions = 0;
self.rocksdb_delete_skipped_count = 0;
self.rocksdb_key_skipped_count = 0;
self.rocksdb_block_cache_hit_count = 0;
self.rocksdb_block_read_count = 0;
self.rocksdb_block_read_byte = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for ScanDetailV2 {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.processed_versions, "processed_versions", buf);
::protobuf::PbPrint::fmt(&self.total_versions, "total_versions", buf);
::protobuf::PbPrint::fmt(&self.rocksdb_delete_skipped_count, "rocksdb_delete_skipped_count", buf);
::protobuf::PbPrint::fmt(&self.rocksdb_key_skipped_count, "rocksdb_key_skipped_count", buf);
::protobuf::PbPrint::fmt(&self.rocksdb_block_cache_hit_count, "rocksdb_block_cache_hit_count", buf);
::protobuf::PbPrint::fmt(&self.rocksdb_block_read_count, "rocksdb_block_read_count", buf);
::protobuf::PbPrint::fmt(&self.rocksdb_block_read_byte, "rocksdb_block_read_byte", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for ScanDetailV2 {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.processed_versions, "processed_versions", &mut s);
::protobuf::PbPrint::fmt(&self.total_versions, "total_versions", &mut s);
::protobuf::PbPrint::fmt(&self.rocksdb_delete_skipped_count, "rocksdb_delete_skipped_count", &mut s);
::protobuf::PbPrint::fmt(&self.rocksdb_key_skipped_count, "rocksdb_key_skipped_count", &mut s);
::protobuf::PbPrint::fmt(&self.rocksdb_block_cache_hit_count, "rocksdb_block_cache_hit_count", &mut s);
::protobuf::PbPrint::fmt(&self.rocksdb_block_read_count, "rocksdb_block_read_count", &mut s);
::protobuf::PbPrint::fmt(&self.rocksdb_block_read_byte, "rocksdb_block_read_byte", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for ScanDetailV2 {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ExecDetails {
pub time_detail: ::protobuf::SingularPtrField<TimeDetail>,
pub scan_detail: ::protobuf::SingularPtrField<ScanDetail>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ExecDetails {
fn default() -> &'a ExecDetails {
<ExecDetails as ::protobuf::Message>::default_instance()
}
}
impl ExecDetails {
pub fn new() -> ExecDetails {
::std::default::Default::default()
}
pub fn get_time_detail(&self) -> &TimeDetail {
self.time_detail.as_ref().unwrap_or_else(|| TimeDetail::default_instance())
}
pub fn clear_time_detail(&mut self) {
self.time_detail.clear();
}
pub fn has_time_detail(&self) -> bool {
self.time_detail.is_some()
}
pub fn set_time_detail(&mut self, v: TimeDetail) {
self.time_detail = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_time_detail(&mut self) -> &mut TimeDetail {
if self.time_detail.is_none() {
self.time_detail.set_default();
}
self.time_detail.as_mut().unwrap()
}
pub fn take_time_detail(&mut self) -> TimeDetail {
self.time_detail.take().unwrap_or_else(|| TimeDetail::new())
}
pub fn get_scan_detail(&self) -> &ScanDetail {
self.scan_detail.as_ref().unwrap_or_else(|| ScanDetail::default_instance())
}
pub fn clear_scan_detail(&mut self) {
self.scan_detail.clear();
}
pub fn has_scan_detail(&self) -> bool {
self.scan_detail.is_some()
}
pub fn set_scan_detail(&mut self, v: ScanDetail) {
self.scan_detail = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_scan_detail(&mut self) -> &mut ScanDetail {
if self.scan_detail.is_none() {
self.scan_detail.set_default();
}
self.scan_detail.as_mut().unwrap()
}
pub fn take_scan_detail(&mut self) -> ScanDetail {
self.scan_detail.take().unwrap_or_else(|| ScanDetail::new())
}
}
impl ::protobuf::Message for ExecDetails {
fn is_initialized(&self) -> bool {
for v in &self.time_detail {
if !v.is_initialized() {
return false;
}
};
for v in &self.scan_detail {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.time_detail)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.scan_detail)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.time_detail.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.scan_detail.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.time_detail.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.scan_detail.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ExecDetails {
ExecDetails::new()
}
fn default_instance() -> &'static ExecDetails {
static mut instance: ::protobuf::lazy::Lazy<ExecDetails> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ExecDetails,
};
unsafe {
instance.get(ExecDetails::new)
}
}
}
impl ::protobuf::Clear for ExecDetails {
fn clear(&mut self) {
self.time_detail.clear();
self.scan_detail.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for ExecDetails {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.time_detail, "time_detail", buf);
::protobuf::PbPrint::fmt(&self.scan_detail, "scan_detail", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for ExecDetails {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.time_detail, "time_detail", &mut s);
::protobuf::PbPrint::fmt(&self.scan_detail, "scan_detail", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for ExecDetails {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ExecDetailsV2 {
pub time_detail: ::protobuf::SingularPtrField<TimeDetail>,
pub scan_detail_v2: ::protobuf::SingularPtrField<ScanDetailV2>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ExecDetailsV2 {
fn default() -> &'a ExecDetailsV2 {
<ExecDetailsV2 as ::protobuf::Message>::default_instance()
}
}
impl ExecDetailsV2 {
pub fn new() -> ExecDetailsV2 {
::std::default::Default::default()
}
pub fn get_time_detail(&self) -> &TimeDetail {
self.time_detail.as_ref().unwrap_or_else(|| TimeDetail::default_instance())
}
pub fn clear_time_detail(&mut self) {
self.time_detail.clear();
}
pub fn has_time_detail(&self) -> bool {
self.time_detail.is_some()
}
pub fn set_time_detail(&mut self, v: TimeDetail) {
self.time_detail = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_time_detail(&mut self) -> &mut TimeDetail {
if self.time_detail.is_none() {
self.time_detail.set_default();
}
self.time_detail.as_mut().unwrap()
}
pub fn take_time_detail(&mut self) -> TimeDetail {
self.time_detail.take().unwrap_or_else(|| TimeDetail::new())
}
pub fn get_scan_detail_v2(&self) -> &ScanDetailV2 {
self.scan_detail_v2.as_ref().unwrap_or_else(|| ScanDetailV2::default_instance())
}
pub fn clear_scan_detail_v2(&mut self) {
self.scan_detail_v2.clear();
}
pub fn has_scan_detail_v2(&self) -> bool {
self.scan_detail_v2.is_some()
}
pub fn set_scan_detail_v2(&mut self, v: ScanDetailV2) {
self.scan_detail_v2 = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_scan_detail_v2(&mut self) -> &mut ScanDetailV2 {
if self.scan_detail_v2.is_none() {
self.scan_detail_v2.set_default();
}
self.scan_detail_v2.as_mut().unwrap()
}
pub fn take_scan_detail_v2(&mut self) -> ScanDetailV2 {
self.scan_detail_v2.take().unwrap_or_else(|| ScanDetailV2::new())
}
}
impl ::protobuf::Message for ExecDetailsV2 {
fn is_initialized(&self) -> bool {
for v in &self.time_detail {
if !v.is_initialized() {
return false;
}
};
for v in &self.scan_detail_v2 {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.time_detail)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.scan_detail_v2)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.time_detail.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.scan_detail_v2.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.time_detail.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.scan_detail_v2.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ExecDetailsV2 {
ExecDetailsV2::new()
}
fn default_instance() -> &'static ExecDetailsV2 {
static mut instance: ::protobuf::lazy::Lazy<ExecDetailsV2> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ExecDetailsV2,
};
unsafe {
instance.get(ExecDetailsV2::new)
}
}
}
impl ::protobuf::Clear for ExecDetailsV2 {
fn clear(&mut self) {
self.time_detail.clear();
self.scan_detail_v2.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for ExecDetailsV2 {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.time_detail, "time_detail", buf);
::protobuf::PbPrint::fmt(&self.scan_detail_v2, "scan_detail_v2", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for ExecDetailsV2 {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.time_detail, "time_detail", &mut s);
::protobuf::PbPrint::fmt(&self.scan_detail_v2, "scan_detail_v2", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for ExecDetailsV2 {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct KvPair {
pub error: ::protobuf::SingularPtrField<KeyError>,
pub key: ::std::vec::Vec<u8>,
pub value: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a KvPair {
fn default() -> &'a KvPair {
<KvPair as ::protobuf::Message>::default_instance()
}
}
impl KvPair {
pub fn new() -> KvPair {
::std::default::Default::default()
}
pub fn get_error(&self) -> &KeyError {
self.error.as_ref().unwrap_or_else(|| KeyError::default_instance())
}
pub fn clear_error(&mut self) {
self.error.clear();
}
pub fn has_error(&self) -> bool {
self.error.is_some()
}
pub fn set_error(&mut self, v: KeyError) {
self.error = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_error(&mut self) -> &mut KeyError {
if self.error.is_none() {
self.error.set_default();
}
self.error.as_mut().unwrap()
}
pub fn take_error(&mut self) -> KeyError {
self.error.take().unwrap_or_else(|| KeyError::new())
}
pub fn get_key(&self) -> &[u8] {
&self.key
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
self.key = v;
}
pub fn mut_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.key
}
pub fn take_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.key, ::std::vec::Vec::new())
}
pub fn get_value(&self) -> &[u8] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::std::vec::Vec<u8>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.value
}
pub fn take_value(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.value, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for KvPair {
fn is_initialized(&self) -> bool {
for v in &self.error {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.error)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.key);
}
if !self.value.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.value);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.error.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.key.is_empty() {
os.write_bytes(2, &self.key)?;
}
if !self.value.is_empty() {
os.write_bytes(3, &self.value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> KvPair {
KvPair::new()
}
fn default_instance() -> &'static KvPair {
static mut instance: ::protobuf::lazy::Lazy<KvPair> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const KvPair,
};
unsafe {
instance.get(KvPair::new)
}
}
}
impl ::protobuf::Clear for KvPair {
fn clear(&mut self) {
self.error.clear();
self.key.clear();
self.value.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for KvPair {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.error, "error", buf);
::protobuf::PbPrint::fmt(&self.key, "key", buf);
::protobuf::PbPrint::fmt(&self.value, "value", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for KvPair {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.error, "error", &mut s);
::protobuf::PbPrint::fmt(&self.key, "key", &mut s);
::protobuf::PbPrint::fmt(&self.value, "value", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for KvPair {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Mutation {
pub op: Op,
pub key: ::std::vec::Vec<u8>,
pub value: ::std::vec::Vec<u8>,
pub assertion: Assertion,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Mutation {
fn default() -> &'a Mutation {
<Mutation as ::protobuf::Message>::default_instance()
}
}
impl Mutation {
pub fn new() -> Mutation {
::std::default::Default::default()
}
pub fn get_op(&self) -> Op {
self.op
}
pub fn clear_op(&mut self) {
self.op = Op::Put;
}
pub fn set_op(&mut self, v: Op) {
self.op = v;
}
pub fn get_key(&self) -> &[u8] {
&self.key
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
self.key = v;
}
pub fn mut_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.key
}
pub fn take_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.key, ::std::vec::Vec::new())
}
pub fn get_value(&self) -> &[u8] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::std::vec::Vec<u8>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.value
}
pub fn take_value(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.value, ::std::vec::Vec::new())
}
pub fn get_assertion(&self) -> Assertion {
self.assertion
}
pub fn clear_assertion(&mut self) {
self.assertion = Assertion::None;
}
pub fn set_assertion(&mut self, v: Assertion) {
self.assertion = v;
}
}
impl ::protobuf::Message for Mutation {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type == ::protobuf::wire_format::WireTypeVarint {self.op = is.read_enum()?;} else {return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));}
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
},
4 => {
if wire_type == ::protobuf::wire_format::WireTypeVarint {self.assertion = is.read_enum()?;} else {return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));}
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.op != Op::Put {
my_size += ::protobuf::rt::enum_size(1, self.op);
}
if !self.key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.key);
}
if !self.value.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.value);
}
if self.assertion != Assertion::None {
my_size += ::protobuf::rt::enum_size(4, self.assertion);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.op != Op::Put {
os.write_enum(1, self.op.value())?;
}
if !self.key.is_empty() {
os.write_bytes(2, &self.key)?;
}
if !self.value.is_empty() {
os.write_bytes(3, &self.value)?;
}
if self.assertion != Assertion::None {
os.write_enum(4, self.assertion.value())?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Mutation {
Mutation::new()
}
fn default_instance() -> &'static Mutation {
static mut instance: ::protobuf::lazy::Lazy<Mutation> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Mutation,
};
unsafe {
instance.get(Mutation::new)
}
}
}
impl ::protobuf::Clear for Mutation {
fn clear(&mut self) {
self.op = Op::Put;
self.key.clear();
self.value.clear();
self.assertion = Assertion::None;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for Mutation {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.op, "op", buf);
::protobuf::PbPrint::fmt(&self.key, "key", buf);
::protobuf::PbPrint::fmt(&self.value, "value", buf);
::protobuf::PbPrint::fmt(&self.assertion, "assertion", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for Mutation {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.op, "op", &mut s);
::protobuf::PbPrint::fmt(&self.key, "key", &mut s);
::protobuf::PbPrint::fmt(&self.value, "value", &mut s);
::protobuf::PbPrint::fmt(&self.assertion, "assertion", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for Mutation {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct MvccWrite {
pub r_type: Op,
pub start_ts: u64,
pub commit_ts: u64,
pub short_value: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MvccWrite {
fn default() -> &'a MvccWrite {
<MvccWrite as ::protobuf::Message>::default_instance()
}
}
impl MvccWrite {
pub fn new() -> MvccWrite {
::std::default::Default::default()
}
pub fn get_type(&self) -> Op {
self.r_type
}
pub fn clear_type(&mut self) {
self.r_type = Op::Put;
}
pub fn set_type(&mut self, v: Op) {
self.r_type = v;
}
pub fn get_start_ts(&self) -> u64 {
self.start_ts
}
pub fn clear_start_ts(&mut self) {
self.start_ts = 0;
}
pub fn set_start_ts(&mut self, v: u64) {
self.start_ts = v;
}
pub fn get_commit_ts(&self) -> u64 {
self.commit_ts
}
pub fn clear_commit_ts(&mut self) {
self.commit_ts = 0;
}
pub fn set_commit_ts(&mut self, v: u64) {
self.commit_ts = v;
}
pub fn get_short_value(&self) -> &[u8] {
&self.short_value
}
pub fn clear_short_value(&mut self) {
self.short_value.clear();
}
pub fn set_short_value(&mut self, v: ::std::vec::Vec<u8>) {
self.short_value = v;
}
pub fn mut_short_value(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.short_value
}
pub fn take_short_value(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.short_value, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for MvccWrite {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type == ::protobuf::wire_format::WireTypeVarint {self.r_type = is.read_enum()?;} else {return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));}
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_ts = tmp;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.commit_ts = tmp;
},
4 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.short_value)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.r_type != Op::Put {
my_size += ::protobuf::rt::enum_size(1, self.r_type);
}
if self.start_ts != 0 {
my_size += ::protobuf::rt::value_size(2, self.start_ts, ::protobuf::wire_format::WireTypeVarint);
}
if self.commit_ts != 0 {
my_size += ::protobuf::rt::value_size(3, self.commit_ts, ::protobuf::wire_format::WireTypeVarint);
}
if !self.short_value.is_empty() {
my_size += ::protobuf::rt::bytes_size(4, &self.short_value);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.r_type != Op::Put {
os.write_enum(1, self.r_type.value())?;
}
if self.start_ts != 0 {
os.write_uint64(2, self.start_ts)?;
}
if self.commit_ts != 0 {
os.write_uint64(3, self.commit_ts)?;
}
if !self.short_value.is_empty() {
os.write_bytes(4, &self.short_value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> MvccWrite {
MvccWrite::new()
}
fn default_instance() -> &'static MvccWrite {
static mut instance: ::protobuf::lazy::Lazy<MvccWrite> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const MvccWrite,
};
unsafe {
instance.get(MvccWrite::new)
}
}
}
impl ::protobuf::Clear for MvccWrite {
fn clear(&mut self) {
self.r_type = Op::Put;
self.start_ts = 0;
self.commit_ts = 0;
self.short_value.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for MvccWrite {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.r_type, "r_type", buf);
::protobuf::PbPrint::fmt(&self.start_ts, "start_ts", buf);
::protobuf::PbPrint::fmt(&self.commit_ts, "commit_ts", buf);
::protobuf::PbPrint::fmt(&self.short_value, "short_value", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for MvccWrite {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.r_type, "r_type", &mut s);
::protobuf::PbPrint::fmt(&self.start_ts, "start_ts", &mut s);
::protobuf::PbPrint::fmt(&self.commit_ts, "commit_ts", &mut s);
::protobuf::PbPrint::fmt(&self.short_value, "short_value", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for MvccWrite {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct MvccValue {
pub start_ts: u64,
pub value: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MvccValue {
fn default() -> &'a MvccValue {
<MvccValue as ::protobuf::Message>::default_instance()
}
}
impl MvccValue {
pub fn new() -> MvccValue {
::std::default::Default::default()
}
pub fn get_start_ts(&self) -> u64 {
self.start_ts
}
pub fn clear_start_ts(&mut self) {
self.start_ts = 0;
}
pub fn set_start_ts(&mut self, v: u64) {
self.start_ts = v;
}
pub fn get_value(&self) -> &[u8] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::std::vec::Vec<u8>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.value
}
pub fn take_value(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.value, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for MvccValue {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_ts = tmp;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.start_ts != 0 {
my_size += ::protobuf::rt::value_size(1, self.start_ts, ::protobuf::wire_format::WireTypeVarint);
}
if !self.value.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.value);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.start_ts != 0 {
os.write_uint64(1, self.start_ts)?;
}
if !self.value.is_empty() {
os.write_bytes(2, &self.value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> MvccValue {
MvccValue::new()
}
fn default_instance() -> &'static MvccValue {
static mut instance: ::protobuf::lazy::Lazy<MvccValue> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const MvccValue,
};
unsafe {
instance.get(MvccValue::new)
}
}
}
impl ::protobuf::Clear for MvccValue {
fn clear(&mut self) {
self.start_ts = 0;
self.value.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for MvccValue {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.start_ts, "start_ts", buf);
::protobuf::PbPrint::fmt(&self.value, "value", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for MvccValue {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.start_ts, "start_ts", &mut s);
::protobuf::PbPrint::fmt(&self.value, "value", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for MvccValue {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct MvccLock {
pub r_type: Op,
pub start_ts: u64,
pub primary: ::std::vec::Vec<u8>,
pub short_value: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MvccLock {
fn default() -> &'a MvccLock {
<MvccLock as ::protobuf::Message>::default_instance()
}
}
impl MvccLock {
pub fn new() -> MvccLock {
::std::default::Default::default()
}
pub fn get_type(&self) -> Op {
self.r_type
}
pub fn clear_type(&mut self) {
self.r_type = Op::Put;
}
pub fn set_type(&mut self, v: Op) {
self.r_type = v;
}
pub fn get_start_ts(&self) -> u64 {
self.start_ts
}
pub fn clear_start_ts(&mut self) {
self.start_ts = 0;
}
pub fn set_start_ts(&mut self, v: u64) {
self.start_ts = v;
}
pub fn get_primary(&self) -> &[u8] {
&self.primary
}
pub fn clear_primary(&mut self) {
self.primary.clear();
}
pub fn set_primary(&mut self, v: ::std::vec::Vec<u8>) {
self.primary = v;
}
pub fn mut_primary(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.primary
}
pub fn take_primary(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.primary, ::std::vec::Vec::new())
}
pub fn get_short_value(&self) -> &[u8] {
&self.short_value
}
pub fn clear_short_value(&mut self) {
self.short_value.clear();
}
pub fn set_short_value(&mut self, v: ::std::vec::Vec<u8>) {
self.short_value = v;
}
pub fn mut_short_value(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.short_value
}
pub fn take_short_value(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.short_value, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for MvccLock {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type == ::protobuf::wire_format::WireTypeVarint {self.r_type = is.read_enum()?;} else {return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));}
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_ts = tmp;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.primary)?;
},
4 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.short_value)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.r_type != Op::Put {
my_size += ::protobuf::rt::enum_size(1, self.r_type);
}
if self.start_ts != 0 {
my_size += ::protobuf::rt::value_size(2, self.start_ts, ::protobuf::wire_format::WireTypeVarint);
}
if !self.primary.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.primary);
}
if !self.short_value.is_empty() {
my_size += ::protobuf::rt::bytes_size(4, &self.short_value);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.r_type != Op::Put {
os.write_enum(1, self.r_type.value())?;
}
if self.start_ts != 0 {
os.write_uint64(2, self.start_ts)?;
}
if !self.primary.is_empty() {
os.write_bytes(3, &self.primary)?;
}
if !self.short_value.is_empty() {
os.write_bytes(4, &self.short_value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> MvccLock {
MvccLock::new()
}
fn default_instance() -> &'static MvccLock {
static mut instance: ::protobuf::lazy::Lazy<MvccLock> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const MvccLock,
};
unsafe {
instance.get(MvccLock::new)
}
}
}
impl ::protobuf::Clear for MvccLock {
fn clear(&mut self) {
self.r_type = Op::Put;
self.start_ts = 0;
self.primary.clear();
self.short_value.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for MvccLock {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.r_type, "r_type", buf);
::protobuf::PbPrint::fmt(&self.start_ts, "start_ts", buf);
::protobuf::PbPrint::fmt(&self.primary, "primary", buf);
::protobuf::PbPrint::fmt(&self.short_value, "short_value", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for MvccLock {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.r_type, "r_type", &mut s);
::protobuf::PbPrint::fmt(&self.start_ts, "start_ts", &mut s);
::protobuf::PbPrint::fmt(&self.primary, "primary", &mut s);
::protobuf::PbPrint::fmt(&self.short_value, "short_value", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for MvccLock {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct MvccInfo {
pub lock: ::protobuf::SingularPtrField<MvccLock>,
pub writes: ::protobuf::RepeatedField<MvccWrite>,
pub values: ::protobuf::RepeatedField<MvccValue>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MvccInfo {
fn default() -> &'a MvccInfo {
<MvccInfo as ::protobuf::Message>::default_instance()
}
}
impl MvccInfo {
pub fn new() -> MvccInfo {
::std::default::Default::default()
}
pub fn get_lock(&self) -> &MvccLock {
self.lock.as_ref().unwrap_or_else(|| MvccLock::default_instance())
}
pub fn clear_lock(&mut self) {
self.lock.clear();
}
pub fn has_lock(&self) -> bool {
self.lock.is_some()
}
pub fn set_lock(&mut self, v: MvccLock) {
self.lock = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_lock(&mut self) -> &mut MvccLock {
if self.lock.is_none() {
self.lock.set_default();
}
self.lock.as_mut().unwrap()
}
pub fn take_lock(&mut self) -> MvccLock {
self.lock.take().unwrap_or_else(|| MvccLock::new())
}
pub fn get_writes(&self) -> &[MvccWrite] {
&self.writes
}
pub fn clear_writes(&mut self) {
self.writes.clear();
}
pub fn set_writes(&mut self, v: ::protobuf::RepeatedField<MvccWrite>) {
self.writes = v;
}
pub fn mut_writes(&mut self) -> &mut ::protobuf::RepeatedField<MvccWrite> {
&mut self.writes
}
pub fn take_writes(&mut self) -> ::protobuf::RepeatedField<MvccWrite> {
::std::mem::replace(&mut self.writes, ::protobuf::RepeatedField::new())
}
pub fn get_values(&self) -> &[MvccValue] {
&self.values
}
pub fn clear_values(&mut self) {
self.values.clear();
}
pub fn set_values(&mut self, v: ::protobuf::RepeatedField<MvccValue>) {
self.values = v;
}
pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<MvccValue> {
&mut self.values
}
pub fn take_values(&mut self) -> ::protobuf::RepeatedField<MvccValue> {
::std::mem::replace(&mut self.values, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for MvccInfo {
fn is_initialized(&self) -> bool {
for v in &self.lock {
if !v.is_initialized() {
return false;
}
};
for v in &self.writes {
if !v.is_initialized() {
return false;
}
};
for v in &self.values {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.lock)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.writes)?;
},
3 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.values)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.lock.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.writes {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
for value in &self.values {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.lock.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.writes {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
for v in &self.values {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> MvccInfo {
MvccInfo::new()
}
fn default_instance() -> &'static MvccInfo {
static mut instance: ::protobuf::lazy::Lazy<MvccInfo> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const MvccInfo,
};
unsafe {
instance.get(MvccInfo::new)
}
}
}
impl ::protobuf::Clear for MvccInfo {
fn clear(&mut self) {
self.lock.clear();
self.writes.clear();
self.values.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for MvccInfo {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.lock, "lock", buf);
::protobuf::PbPrint::fmt(&self.writes, "writes", buf);
::protobuf::PbPrint::fmt(&self.values, "values", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for MvccInfo {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.lock, "lock", &mut s);
::protobuf::PbPrint::fmt(&self.writes, "writes", &mut s);
::protobuf::PbPrint::fmt(&self.values, "values", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for MvccInfo {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxnInfo {
pub txn: u64,
pub status: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxnInfo {
fn default() -> &'a TxnInfo {
<TxnInfo as ::protobuf::Message>::default_instance()
}
}
impl TxnInfo {
pub fn new() -> TxnInfo {
::std::default::Default::default()
}
pub fn get_txn(&self) -> u64 {
self.txn
}
pub fn clear_txn(&mut self) {
self.txn = 0;
}
pub fn set_txn(&mut self, v: u64) {
self.txn = v;
}
pub fn get_status(&self) -> u64 {
self.status
}
pub fn clear_status(&mut self) {
self.status = 0;
}
pub fn set_status(&mut self, v: u64) {
self.status = v;
}
}
impl ::protobuf::Message for TxnInfo {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.txn = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.status = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.txn != 0 {
my_size += ::protobuf::rt::value_size(1, self.txn, ::protobuf::wire_format::WireTypeVarint);
}
if self.status != 0 {
my_size += ::protobuf::rt::value_size(2, self.status, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.txn != 0 {
os.write_uint64(1, self.txn)?;
}
if self.status != 0 {
os.write_uint64(2, self.status)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> TxnInfo {
TxnInfo::new()
}
fn default_instance() -> &'static TxnInfo {
static mut instance: ::protobuf::lazy::Lazy<TxnInfo> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const TxnInfo,
};
unsafe {
instance.get(TxnInfo::new)
}
}
}
impl ::protobuf::Clear for TxnInfo {
fn clear(&mut self) {
self.txn = 0;
self.status = 0;
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for TxnInfo {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.txn, "txn", buf);
::protobuf::PbPrint::fmt(&self.status, "status", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for TxnInfo {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.txn, "txn", &mut s);
::protobuf::PbPrint::fmt(&self.status, "status", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for TxnInfo {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct KeyRange {
pub start_key: ::std::vec::Vec<u8>,
pub end_key: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a KeyRange {
fn default() -> &'a KeyRange {
<KeyRange as ::protobuf::Message>::default_instance()
}
}
impl KeyRange {
pub fn new() -> KeyRange {
::std::default::Default::default()
}
pub fn get_start_key(&self) -> &[u8] {
&self.start_key
}
pub fn clear_start_key(&mut self) {
self.start_key.clear();
}
pub fn set_start_key(&mut self, v: ::std::vec::Vec<u8>) {
self.start_key = v;
}
pub fn mut_start_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.start_key
}
pub fn take_start_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.start_key, ::std::vec::Vec::new())
}
pub fn get_end_key(&self) -> &[u8] {
&self.end_key
}
pub fn clear_end_key(&mut self) {
self.end_key.clear();
}
pub fn set_end_key(&mut self, v: ::std::vec::Vec<u8>) {
self.end_key = v;
}
pub fn mut_end_key(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.end_key
}
pub fn take_end_key(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.end_key, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for KeyRange {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.start_key)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.end_key)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.start_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(1, &self.start_key);
}
if !self.end_key.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.end_key);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.start_key.is_empty() {
os.write_bytes(1, &self.start_key)?;
}
if !self.end_key.is_empty() {
os.write_bytes(2, &self.end_key)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> KeyRange {
KeyRange::new()
}
fn default_instance() -> &'static KeyRange {
static mut instance: ::protobuf::lazy::Lazy<KeyRange> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const KeyRange,
};
unsafe {
instance.get(KeyRange::new)
}
}
}
impl ::protobuf::Clear for KeyRange {
fn clear(&mut self) {
self.start_key.clear();
self.end_key.clear();
self.unknown_fields.clear();
}
}
impl ::protobuf::PbPrint for KeyRange {
#[allow(unused_variables)]
fn fmt(&self, name: &str, buf: &mut String) {
::protobuf::push_message_start(name, buf);
let old_len = buf.len();
::protobuf::PbPrint::fmt(&self.start_key, "start_key", buf);
::protobuf::PbPrint::fmt(&self.end_key, "end_key", buf);
if old_len < buf.len() {
buf.push(' ');
}
buf.push('}');
}
}
impl ::std::fmt::Debug for KeyRange {
#[allow(unused_variables)]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut s = String::new();
::protobuf::PbPrint::fmt(&self.start_key, "start_key", &mut s);
::protobuf::PbPrint::fmt(&self.end_key, "end_key", &mut s);
write!(f, "{}", s)
}
}
impl ::protobuf::reflect::ProtobufValue for KeyRange {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum VerOp {
VerPut = 0,
VerDel = 1,
}
impl ::protobuf::ProtobufEnum for VerOp {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<VerOp> {
match value {
0 => ::std::option::Option::Some(VerOp::VerPut),
1 => ::std::option::Option::Some(VerOp::VerDel),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [VerOp] = &[
VerOp::VerPut,
VerOp::VerDel,
];
values
}
}
impl ::std::marker::Copy for VerOp {
}
impl ::protobuf::PbPrint for VerOp {
fn fmt(&self, name: &str, buf: &mut String) {
use std::fmt::Write;
if *self == VerOp::default() {
return;
}
::protobuf::push_field_start(name, buf);
write!(buf, "{:?}", self).unwrap();
}
}
impl ::std::default::Default for VerOp {
fn default() -> Self {
VerOp::VerPut
}
}
impl ::protobuf::reflect::ProtobufValue for VerOp {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum CommandPri {
Normal = 0,
Low = 1,
High = 2,
}
impl ::protobuf::ProtobufEnum for CommandPri {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<CommandPri> {
match value {
0 => ::std::option::Option::Some(CommandPri::Normal),
1 => ::std::option::Option::Some(CommandPri::Low),
2 => ::std::option::Option::Some(CommandPri::High),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [CommandPri] = &[
CommandPri::Normal,
CommandPri::Low,
CommandPri::High,
];
values
}
}
impl ::std::marker::Copy for CommandPri {
}
impl ::protobuf::PbPrint for CommandPri {
fn fmt(&self, name: &str, buf: &mut String) {
use std::fmt::Write;
if *self == CommandPri::default() {
return;
}
::protobuf::push_field_start(name, buf);
write!(buf, "{:?}", self).unwrap();
}
}
impl ::std::default::Default for CommandPri {
fn default() -> Self {
CommandPri::Normal
}
}
impl ::protobuf::reflect::ProtobufValue for CommandPri {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum IsolationLevel {
Si = 0,
Rc = 1,
}
impl ::protobuf::ProtobufEnum for IsolationLevel {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<IsolationLevel> {
match value {
0 => ::std::option::Option::Some(IsolationLevel::Si),
1 => ::std::option::Option::Some(IsolationLevel::Rc),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [IsolationLevel] = &[
IsolationLevel::Si,
IsolationLevel::Rc,
];
values
}
}
impl ::std::marker::Copy for IsolationLevel {
}
impl ::protobuf::PbPrint for IsolationLevel {
fn fmt(&self, name: &str, buf: &mut String) {
use std::fmt::Write;
if *self == IsolationLevel::default() {
return;
}
::protobuf::push_field_start(name, buf);
write!(buf, "{:?}", self).unwrap();
}
}
impl ::std::default::Default for IsolationLevel {
fn default() -> Self {
IsolationLevel::Si
}
}
impl ::protobuf::reflect::ProtobufValue for IsolationLevel {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum Op {
Put = 0,
Del = 1,
Lock = 2,
Rollback = 3,
Insert = 4,
PessimisticLock = 5,
CheckNotExists = 6,
}
impl ::protobuf::ProtobufEnum for Op {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<Op> {
match value {
0 => ::std::option::Option::Some(Op::Put),
1 => ::std::option::Option::Some(Op::Del),
2 => ::std::option::Option::Some(Op::Lock),
3 => ::std::option::Option::Some(Op::Rollback),
4 => ::std::option::Option::Some(Op::Insert),
5 => ::std::option::Option::Some(Op::PessimisticLock),
6 => ::std::option::Option::Some(Op::CheckNotExists),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [Op] = &[
Op::Put,
Op::Del,
Op::Lock,
Op::Rollback,
Op::Insert,
Op::PessimisticLock,
Op::CheckNotExists,
];
values
}
}
impl ::std::marker::Copy for Op {
}
impl ::protobuf::PbPrint for Op {
fn fmt(&self, name: &str, buf: &mut String) {
use std::fmt::Write;
if *self == Op::default() {
return;
}
::protobuf::push_field_start(name, buf);
write!(buf, "{:?}", self).unwrap();
}
}
impl ::std::default::Default for Op {
fn default() -> Self {
Op::Put
}
}
impl ::protobuf::reflect::ProtobufValue for Op {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum Assertion {
None = 0,
Exist = 1,
NotExist = 2,
}
impl ::protobuf::ProtobufEnum for Assertion {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<Assertion> {
match value {
0 => ::std::option::Option::Some(Assertion::None),
1 => ::std::option::Option::Some(Assertion::Exist),
2 => ::std::option::Option::Some(Assertion::NotExist),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [Assertion] = &[
Assertion::None,
Assertion::Exist,
Assertion::NotExist,
];
values
}
}
impl ::std::marker::Copy for Assertion {
}
impl ::protobuf::PbPrint for Assertion {
fn fmt(&self, name: &str, buf: &mut String) {
use std::fmt::Write;
if *self == Assertion::default() {
return;
}
::protobuf::push_field_start(name, buf);
write!(buf, "{:?}", self).unwrap();
}
}
impl ::std::default::Default for Assertion {
fn default() -> Self {
Assertion::None
}
}
impl ::protobuf::reflect::ProtobufValue for Assertion {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum Action {
NoAction = 0,
TtlExpireRollback = 1,
LockNotExistRollback = 2,
MinCommitTsPushed = 3,
}
impl ::protobuf::ProtobufEnum for Action {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<Action> {
match value {
0 => ::std::option::Option::Some(Action::NoAction),
1 => ::std::option::Option::Some(Action::TtlExpireRollback),
2 => ::std::option::Option::Some(Action::LockNotExistRollback),
3 => ::std::option::Option::Some(Action::MinCommitTsPushed),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [Action] = &[
Action::NoAction,
Action::TtlExpireRollback,
Action::LockNotExistRollback,
Action::MinCommitTsPushed,
];
values
}
}
impl ::std::marker::Copy for Action {
}
impl ::protobuf::PbPrint for Action {
fn fmt(&self, name: &str, buf: &mut String) {
use std::fmt::Write;
if *self == Action::default() {
return;
}
::protobuf::push_field_start(name, buf);
write!(buf, "{:?}", self).unwrap();
}
}
impl ::std::default::Default for Action {
fn default() -> Self {
Action::NoAction
}
}
impl ::protobuf::reflect::ProtobufValue for Action {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum ExtraOp {
Noop = 0,
ReadOldValue = 1,
}
impl ::protobuf::ProtobufEnum for ExtraOp {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<ExtraOp> {
match value {
0 => ::std::option::Option::Some(ExtraOp::Noop),
1 => ::std::option::Option::Some(ExtraOp::ReadOldValue),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [ExtraOp] = &[
ExtraOp::Noop,
ExtraOp::ReadOldValue,
];
values
}
}
impl ::std::marker::Copy for ExtraOp {
}
impl ::protobuf::PbPrint for ExtraOp {
fn fmt(&self, name: &str, buf: &mut String) {
use std::fmt::Write;
if *self == ExtraOp::default() {
return;
}
::protobuf::push_field_start(name, buf);
write!(buf, "{:?}", self).unwrap();
}
}
impl ::std::default::Default for ExtraOp {
fn default() -> Self {
ExtraOp::Noop
}
}
impl ::protobuf::reflect::ProtobufValue for ExtraOp {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
}
}